From e317e7511efc142f478da07291dd151d76f2f4b7 Mon Sep 17 00:00:00 2001 From: Katherine Parry Date: Sat, 20 Mar 2021 02:05:16 +0000 Subject: [PATCH] messy FMA rewrite using section 7.5.4 in The Handbook of Floating-Point Arithmetic --- wally-pipelined/src/fpu/FMA/{add.v => add.sv} | 23 +- .../src/fpu/FMA/{align.v => align.sv} | 72 +- wally-pipelined/src/fpu/FMA/array.sv | 114 - wally-pipelined/src/fpu/FMA/booth.sv | 55 - wally-pipelined/src/fpu/FMA/bypass.v | 30 - wally-pipelined/src/fpu/FMA/compressors.sv | 90 - .../src/fpu/FMA/{expgen.v => expgen.sv} | 61 +- .../src/fpu/FMA/{flag.v => flag.sv} | 6 +- wally-pipelined/src/fpu/FMA/fmac.sv | 138 + wally-pipelined/src/fpu/FMA/fmac.v | 130 - wally-pipelined/src/fpu/FMA/{lop.v => lza.sv} | 6 +- wally-pipelined/src/fpu/FMA/multiply.sv | 15 + .../src/fpu/FMA/{normalize.v => normalize.sv} | 45 +- .../src/fpu/FMA/{round.v => round.sv} | 29 +- .../src/fpu/FMA/{sign.v => sign.sv} | 2 + .../src/fpu/FMA/{special.v => special.sv} | 2 +- wally-pipelined/src/fpu/FMA/tb.v | 2824 - wally-pipelined/src/fpu/FMA/tbgen/ans | 199 - wally-pipelined/src/fpu/FMA/tbgen/output | 199 - wally-pipelined/src/fpu/FMA/tbgen/results.srt | 111 + wally-pipelined/src/fpu/FMA/tbgen/tb | Bin 13160 -> 13160 bytes wally-pipelined/src/fpu/FMA/tbgen/tb.c | 40 +- wally-pipelined/src/fpu/FMA/tbgen/tb.v | 548534 +++------------ wally-pipelined/src/fpu/FMA/tbgen/tbhead.v | 8 +- 24 files changed, 115026 insertions(+), 437707 deletions(-) rename wally-pipelined/src/fpu/FMA/{add.v => add.sv} (74%) rename wally-pipelined/src/fpu/FMA/{align.v => align.sv} (58%) delete mode 100644 wally-pipelined/src/fpu/FMA/array.sv delete mode 100644 wally-pipelined/src/fpu/FMA/booth.sv delete mode 100644 wally-pipelined/src/fpu/FMA/bypass.v delete mode 100644 wally-pipelined/src/fpu/FMA/compressors.sv rename wally-pipelined/src/fpu/FMA/{expgen.v => expgen.sv} (69%) rename wally-pipelined/src/fpu/FMA/{flag.v => flag.sv} (94%) create mode 100644 wally-pipelined/src/fpu/FMA/fmac.sv delete mode 100644 wally-pipelined/src/fpu/FMA/fmac.v rename wally-pipelined/src/fpu/FMA/{lop.v => lza.sv} (88%) create mode 100644 wally-pipelined/src/fpu/FMA/multiply.sv rename wally-pipelined/src/fpu/FMA/{normalize.v => normalize.sv} (59%) rename wally-pipelined/src/fpu/FMA/{round.v => round.sv} (81%) rename wally-pipelined/src/fpu/FMA/{sign.v => sign.sv} (97%) rename wally-pipelined/src/fpu/FMA/{special.v => special.sv} (97%) delete mode 100644 wally-pipelined/src/fpu/FMA/tb.v delete mode 100644 wally-pipelined/src/fpu/FMA/tbgen/ans delete mode 100644 wally-pipelined/src/fpu/FMA/tbgen/output create mode 100644 wally-pipelined/src/fpu/FMA/tbgen/results.srt diff --git a/wally-pipelined/src/fpu/FMA/add.v b/wally-pipelined/src/fpu/FMA/add.sv similarity index 74% rename from wally-pipelined/src/fpu/FMA/add.v rename to wally-pipelined/src/fpu/FMA/add.sv index 65d20d6e..05a6fd7e 100644 --- a/wally-pipelined/src/fpu/FMA/add.v +++ b/wally-pipelined/src/fpu/FMA/add.sv @@ -11,19 +11,19 @@ //////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////// -module add(r[105:0], s[105:0], t[157:0], sum[157:0], +module add(r, s, t, sum, negsum, invz, selsum1, killprod, negsum0, negsum1, proddenorm); //////////////////////////////////////////////////////////////////////////////// input [105:0] r; // partial product 1 input [105:0] s; // partial product 2 - input [157:0] t; // aligned addend + input [163:0] t; // aligned addend input invz; // invert addend input selsum1; // select +1 mode of compound adder input killprod; // z >> product input negsum; // Negate sum input proddenorm; - output [157:0] sum; // sum + output [163:0] sum; // sum output negsum0; // sum was negative in +0 mode output negsum1; // sum was negative in +1 mode @@ -31,13 +31,14 @@ module add(r[105:0], s[105:0], t[157:0], sum[157:0], wire [105:0] r2; // partial product possibly zeroed out wire [105:0] s2; // partial product possibly zeroed out - wire [157:0] t2; // addend after inversion if necessary - wire [157:0] sum0; // sum of compound adder +0 mode - wire [157:0] sum1; // sum of compound adder +1 mode + wire [163:0] t2; // addend after inversion if necessary + wire [163:0] sum0; // sum of compound adder +0 mode + wire [163:0] sum1; // sum of compound adder +1 mode + wire [163:0] prodshifted; // sum of compound adder +1 mode // Invert addend if z's sign is diffrent from the product's sign - assign t2 = invz ? -t : t; + assign t2 = invz ? ~t : t; // Zero out product if Z >> product or product really should be zero @@ -46,9 +47,9 @@ module add(r[105:0], s[105:0], t[157:0], sum[157:0], // Compound adder // Consists of 3:2 CSA followed by long compound CPA - - assign sum0 = {52'b0, r2} + {52'b0, s2} + t2 + 158'b0; - assign sum1 = {52'b0, r2} + {52'b0, s2} + t2 + 158'b1; + assign prodshifted = {56'b0, r2, 2'b0} + {56'b0, s2, 2'b0}; + assign sum0 = prodshifted + t2 + 158'b0; + assign sum1 = prodshifted + t2 + 158'b1; // Check sign bits in +0/1 modes assign negsum0 = sum0[157]; @@ -56,6 +57,6 @@ module add(r[105:0], s[105:0], t[157:0], sum[157:0], // Mux proper result (+Oil mode and inversion) using 4:1 mux - assign sum = selsum1 ? (negsum ? ~sum1 : sum1) : (negsum ? ~sum0 : sum0); + assign sum = selsum1 ? (negsum ? -sum1 : sum1) : (negsum ? -sum0 : sum0); endmodule diff --git a/wally-pipelined/src/fpu/FMA/align.v b/wally-pipelined/src/fpu/FMA/align.sv similarity index 58% rename from wally-pipelined/src/fpu/FMA/align.v rename to wally-pipelined/src/fpu/FMA/align.sv index e70ef7f3..040f7862 100644 --- a/wally-pipelined/src/fpu/FMA/align.v +++ b/wally-pipelined/src/fpu/FMA/align.sv @@ -11,11 +11,11 @@ ///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// -module align(z[51:0], ae[12:0], aligncnt, xzero, yzero, zzero, zdenorm, proddenorm, t[157:0], bs, ps, - killprod, bypsel[1], bypplus1, byppostnorm); +module align(zman, ae, aligncnt, xzero, yzero, zzero, zdenorm, proddenorm, t, bs, ps, + killprod, zexpsel, sumshift); ///////////////////////////////////////////////////////////////////////////// - input [51:0] z; // Fraction of addend z; + input [51:0] zman; // Fraction of addend z; input [12:0] ae; // sign of exponent of addend z; input [11:0] aligncnt; // amount to shift input xzero; // Input X = 0 @@ -23,30 +23,28 @@ module align(z[51:0], ae[12:0], aligncnt, xzero, yzero, zzero, zdenorm, proddeno input zzero; // Input Z = 0 input zdenorm; // Input Z is denormalized input proddenorm; // product is denormalized - input [1:1] bypsel; // Select bypass to X or Z - input bypplus1; // Add one to bypassed result - input byppostnorm; // Postnormalize bypassed result - output [157:0] t; // aligned addend (54 bits left of bpt) + output [163:0] t; // aligned addend (54 bits left of bpt) output bs; // sticky bit of addend output ps; // sticky bit of product output killprod; // Z >> product + output zexpsel; // Z >> product + output [7:0] sumshift; // Internal nodes - reg [157:0] t; // aligned addend from shifter + reg [163:0] t; // aligned addend from shifter + reg [215:0] shift; // aligned addend from shifter reg killprod; // Z >> product reg bs; // sticky bit of addend reg ps; // sticky bit of product + reg zexpsel; // sticky bit of product reg [7:0] i; // temp storage for finding sticky bit wire [52:0] z1; // Z plus 1 wire [51:0] z2; // Z selected after handling rounds wire [11:0] align104; // alignment count + 104 + logic [8:0] sumshift; - // Increment fraction of Z by one if necessary for prerounded bypass - // This incrementor delay is masked by the alignment count computation - assign z1 = z + 1; - assign z2 = bypsel[1] && bypplus1 ? (byppostnorm ? z1[52:1] : z1[51:0]): z; // Compute sign of aligncnt + 104 to check for shifting too far right @@ -66,27 +64,35 @@ module align(z[51:0], ae[12:0], aligncnt, xzero, yzero, zzero, zdenorm, proddeno // And to using product as primary operand in adder I exponent gen killprod = 0; - if(zzero) begin // if z = 0 - t = 158'b0; - if (xzero || yzero) killprod = 1; - end else if ((aligncnt > 53 && ~aligncnt[11]) || xzero || yzero) begin - // Left shift by huge amount - // or product = 0 - t = {53'b0, ~zzero, z2, 52'b0}; - killprod = 1; - ps = ~xzero && ~yzero; - end else if ((ae[12] && align104[11]) && ~proddenorm) begin //***fix the if statement - // KEP if the multiplier's exponent overflows - t = {53'b0, ~zzero, z2, 52'b0}; - killprod = 1; - ps = ~xzero && ~yzero; - end else if(align104[11]) begin // Right shift by huge amount - bs = ~zzero; - t = 0; - end else if (~aligncnt[11]) begin // Left shift by reasonable amount - t = {53'b0, ~zzero, z2, 52'b0} << aligncnt; - end else begin // Otherwise right shift - t = {53'b0, ~zzero, z2, 52'b0} >> -aligncnt; + if ($signed(aligncnt) <= $signed(-105)) begin //ae<=-103 + //product ancored case with saturated shift + sumshift = 163; + shift = {~zdenorm,zman,163'b0} >> sumshift; + t = {shift[208:51]}; + bs = |(shift[50:0]); + //bs = ~zzero; //set sticky bit + zexpsel = 0; + end else if($signed(aligncnt) <= $signed(2)) begin // -103> sumshift; + t = {shift[208:51]}; + bs = |(shift[51:0]); + zexpsel = 0; + end else if ($signed(aligncnt)<=$signed(55)) begin //2> sumshift; + t = {shift[208:51]}; + bs = |(shift[51:0]); + zexpsel = 1; + end else begin // ae>= 55 + // addend anchored case with saturated shift + sumshift = 0; + shift = {~zdenorm,zman, 163'b0} >> sumshift; + t = {shift[215:52]}; + bs = |(shift[51:0]); + zexpsel = 1; // use some behavioral code to find sticky bit. This is really // done by hardware in the shifter. diff --git a/wally-pipelined/src/fpu/FMA/array.sv b/wally-pipelined/src/fpu/FMA/array.sv deleted file mode 100644 index 70492614..00000000 --- a/wally-pipelined/src/fpu/FMA/array.sv +++ /dev/null @@ -1,114 +0,0 @@ - -module array(x, y, xdenorm, ydenorm, r, s, bypsel, bypplus1); -///////////////////////////////////////////////////////////////////////////// - - input [51:0] x; // Fraction of multiplicand x - input [51:0] y; // Fraction of multiplicand y - input xdenorm; // is x denormalized - input ydenorm; // is y denormalized - input bypsel; // Bypass X - input bypplus1; // Add 1 to X to handle rounding - output [105:0] r; // partial product 1 - output [105:0] s; // partial product 2 - - wire [51:0] xnorm; - wire [51:0] ynorm; - - wire [54:0] yExt; //y with appended 0 and assumed 1 - wire [53:0] xExt; //y with assumed 1 - wire [26:0][1:0] add1; - wire [26:0][54:0] pp; - wire [26:0] e; - logic [17:0][105:0] lv1add; - logic [11:0][105:0] lv2add; - logic [7:0][105:0] lv3add; - logic [3:0][105:0] lv4add; - logic [21:0][106:0] carryTmp; - wire [26:0][105:0] acc; - // wire [105:0] acc - genvar i; - - assign xnorm = xdenorm ? {x[50:0], 1'b0} : x; // normalization of denormalized numbers - assign ynorm = ydenorm ? {y[50:0], 1'b0} : y; - //assign yExt = {2'b01,ynorm,1'b0}; // y extended and added assumed 1 - //assign xExt = {2'b01,xnorm}; // x with added assumed 1 - - - //booth encoding - - // generate - // for(i=0; i<27; i=i+1) begin - // booth booth(.xExt(xExt), .choose(yExt[(i*2)+2:i*2]), .add1(add1[i]), .e(e[i]), .pp(pp[i])); - // end - // endgenerate - - // assign acc[0] = {49'b0,~e[0],e[0],e[0],pp[0]}; - // assign acc[1] = {50'b01,~e[1],pp[1],add1[0]}; - // assign acc[2] = {48'b01,~e[2],pp[2],add1[1], 2'b0}; - // assign acc[3] = {46'b01,~e[3],pp[3],add1[2], 4'b0}; - // assign acc[4] = {44'b01,~e[4],pp[4],add1[3], 6'b0}; - // assign acc[5] = {42'b01,~e[5],pp[5],add1[4], 8'b0}; - // assign acc[6] = {40'b01,~e[6],pp[6],add1[5], 10'b0}; - // assign acc[7] = {38'b01,~e[7],pp[7],add1[6], 12'b0}; - // assign acc[8] = {36'b01,~e[8],pp[8],add1[7], 14'b0}; - // assign acc[9] = {34'b01,~e[9],pp[9],add1[8], 16'b0}; - // assign acc[10] = {32'b01,~e[10],pp[10],add1[9], 18'b0}; - // assign acc[11] = {30'b01,~e[11],pp[11],add1[10], 20'b0}; - // assign acc[12] = {28'b01,~e[12],pp[12],add1[11], 22'b0}; - // assign acc[13] = {26'b01,~e[13],pp[13],add1[12], 24'b0}; - // assign acc[14] = {24'b01,~e[14],pp[14],add1[13], 26'b0}; - // assign acc[15] = {22'b01,~e[15],pp[15],add1[14], 28'b0}; - // assign acc[16] = {20'b01,~e[16],pp[16],add1[15], 30'b0}; - // assign acc[17] = {18'b01,~e[17],pp[17],add1[16], 32'b0}; - // assign acc[18] = {16'b01,~e[18],pp[18],add1[17], 34'b0}; - // assign acc[19] = {14'b01,~e[19],pp[19],add1[18], 36'b0}; - // assign acc[20] = {12'b01,~e[20],pp[20],add1[19], 38'b0}; - // assign acc[21] = {10'b01,~e[21],pp[21],add1[20], 40'b0}; - // assign acc[22] = {8'b01,~e[22],pp[22],add1[21], 42'b0}; - // assign acc[23] = {6'b01,~e[23],pp[23],add1[22], 44'b0}; - // assign acc[24] = {4'b01,~e[24],pp[24],add1[23], 46'b0}; - // assign acc[25] = {~e[25],pp[25],add1[24], 48'b0}; - // assign acc[26] = {pp[26],add1[25], 50'b0}; - - // //*** resize adders - // generate - // for(i=0; i<9; i=i+1) begin - // add3comp2 #(.BITS(106)) add1(.a(acc[i*3]), .b(acc[i*3+1]), .c(acc[i*3+2]), - // .carry(carryTmp[i][105:0]), .sum(lv1add[i*2+1])); - // assign lv1add[i*2] = {carryTmp[i][104:0], 1'b0}; - // end - // endgenerate - - // generate - // for(i=0; i<6; i=i+1) begin - // add3comp2 #(.BITS(106)) add2(.a(lv1add[i*3]), .b(lv1add[i*3+1]), .c(lv1add[i*3+2]), - // .carry(carryTmp[i+9][105:0]), .sum(lv2add[i*2+1])); - // assign lv2add[i*2] = {carryTmp[i+9][104:0], 1'b0}; - // end - // endgenerate - - // generate - // for(i=0; i<4; i=i+1) begin - // add3comp2 #(.BITS(106)) add3(.a(lv2add[i*3]), .b(lv2add[i*3+1]), .c(lv2add[i*3+2]), - // .carry(carryTmp[i+15][105:0]), .sum(lv3add[i*2+1])); - // assign lv3add[i*2] = {carryTmp[i+15][104:0], 1'b0}; - // end - // endgenerate - - - // generate - // for(i=0; i<2; i=i+1) begin - // add4comp2 #(.BITS(106)) add4(.a(lv3add[i*4]), .b(lv3add[i*4+1]), .c(lv3add[i*4+2]), .d(lv3add[i*4+3]), - // .carry(carryTmp[i+19]), .sum(lv4add[i*2+1])); - // assign lv4add[i*2] = {carryTmp[i+19][104:0], 1'b0}; - // end - // endgenerate - - // add4comp2 #(.BITS(106)) add5(.a(lv4add[0]), .b(lv4add[1]), .c(lv4add[2]), .d(lv4add[3]) , - // .carry(carryTmp[21]), .sum(s)); - // assign r = {carryTmp[21][104:0], 1'b0}; - - assign r = 106'b0; - assign s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - -endmodule diff --git a/wally-pipelined/src/fpu/FMA/booth.sv b/wally-pipelined/src/fpu/FMA/booth.sv deleted file mode 100644 index 46ad22e5..00000000 --- a/wally-pipelined/src/fpu/FMA/booth.sv +++ /dev/null @@ -1,55 +0,0 @@ -module booth(xExt, choose, add1, e, pp); -///////////////////////////////////////////////////////////////////////////// - - input [53:0] xExt; // multiplicand xExt - input [2:0] choose; // bits needed to choose which encoding - output [1:0] add1; // do you add 1 - output e; - output [54:0] pp; // the resultant encoding - - logic [54:0] pp, temp; - logic e; - logic [1:0] add1; - logic [53:0] negx; - //logic temp; - - assign negx = ~xExt; - - always @(choose, xExt, negx) - case (choose) - 3'b000 : pp = 55'b0; // 0 - 3'b001 : pp = {xExt[53], xExt}; // 1 - 3'b010 : pp = {xExt[53], xExt}; // 1 - 3'b011 : pp = {xExt, 1'b0}; // 2 - 3'b100 : pp = {negx, 1'b0}; // -2 - 3'b101 : pp = {negx[53], negx}; // -1 - 3'b110 : pp = {negx[53], negx}; // -1 - 3'b111 : pp = 55'hfffffffffffffff; // -0 - endcase - - always @(choose, xExt, negx) - case (choose) - 3'b000 : e = 0; // 0 - 3'b001 : e = xExt[53]; // 1 - 3'b010 : e = xExt[53]; // 1 - 3'b011 : e = xExt[53]; // 2 - 3'b100 : e = negx[53]; // -2 - 3'b101 : e = negx[53]; // -1 - 3'b110 : e = negx[53]; // -1 - 3'b111 : e = 1; // -0 - endcase - // assign add1 = (choose[2] == 1'b1) ? ((choose[1:0] == 2'b11) ? 1'b0 : 1'b1) : 1'b0; - // assign add1 = choose[2]; - always @(choose) - case (choose) - 3'b000 : add1 = 2'b0; // 0 - 3'b001 : add1 = 2'b0; // 1 - 3'b010 : add1 = 2'b0; // 1 - 3'b011 : add1 = 2'b0; // 2 - 3'b100 : add1 = 2'b10; // -2 - 3'b101 : add1 = 2'b1; // -1 - 3'b110 : add1 = 2'b1; // -1 - 3'b111 : add1 = 2'b1; // -0 - endcase - -endmodule diff --git a/wally-pipelined/src/fpu/FMA/bypass.v b/wally-pipelined/src/fpu/FMA/bypass.v deleted file mode 100644 index 4a035c1b..00000000 --- a/wally-pipelined/src/fpu/FMA/bypass.v +++ /dev/null @@ -1,30 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// Block Name: bypass.v -// Author: David Harris -// Date: 11/2/1995 -// -// Block Description: -// This block contains the bypass muxes which allow fast prerounded -// bypass to the X and Z inputs of the FMAC -// -///////////////////////////////////////////////////////////////////////////// - -///////////////////////////////////////////////////////////////////////////// -module bypass(xrf[63:0], zrf[63:0], wbypass[63:0], bypsel[1:0], - x[63:0], z[63:0]); -///////////////////////////////////////////////////////////////////////////// - - input [63:0] xrf; // X from register file - input [63:0] zrf; // Z from register file - input [63:0] wbypass; // Prerounded result for bypass - input [1:0] bypsel; // Select bypass to X or Z - output [63:0] x; // Source X - output [63:0] z; // Source Z - - // If bypass select is asserted, bypass source, else take reg file value - - assign x = bypsel[0] ? wbypass : xrf; - assign z = bypsel[1] ? wbypass : zrf; - -endmodule diff --git a/wally-pipelined/src/fpu/FMA/compressors.sv b/wally-pipelined/src/fpu/FMA/compressors.sv deleted file mode 100644 index 9dd3fc11..00000000 --- a/wally-pipelined/src/fpu/FMA/compressors.sv +++ /dev/null @@ -1,90 +0,0 @@ -module add3comp2(a, b, c, carry, sum); -///////////////////////////////////////////////////////////////////////////// -//look into diffrent implementations of the compressors? - - parameter BITS = 4; - input [BITS-1:0] a; - input [BITS-1:0] b; - input [BITS-1:0] c; - output [BITS-1:0] carry; - output [BITS-1:0] sum; - genvar i; - - generate - for(i= 0; i> product input sumzero; // sum exactly equals zero - input postnormalize; // postnormalize rounded result + input resultdenorm; // postnormalize rounded result input [8:0] normcnt; // normalization shift count input infinity; // generate infinity on overflow input invalid; // Result invalid @@ -41,15 +36,18 @@ module expgen(x[62:52], y[62:52], z[62:52], input underflow; // Result underflowed input inf; // Some input is infinity input nan; // Some input is NaN + input [12:0] de0; // X is NaN NaN input xnan; // X is NaN input ynan; // Y is NaN input znan; // Z is NaN + input xdenorm; // Z is denorm + input ydenorm; // Z is denorm input zdenorm; // Z is denorm input proddenorm; // product is denorm input specialsel; // Select special result + input zexpsel; // Select special result output [11:0] aligncnt; // shift count for alignment shifter - output [62:52] w; // Exponent of result - output [62:52] wbypass; // Prerounded exponent for bypass + output [62:52] wexp; // Exponent of result output prodof; // X*Y exponent out of bounds output sumof; // X*Y+Z exponent out of bounds output sumuf; // X*Y+Z exponent underflows @@ -62,7 +60,6 @@ module expgen(x[62:52], y[62:52], z[62:52], wire [12:0] aligncnt0; // Shift count for alignment wire [12:0] aligncnt1; // Shift count for alignment wire [12:0] be; // Exponent of multiply - wire [12:0] de0; // Normalized exponent wire [12:0] de1; // Normalized exponent wire [12:0] de; // Normalized exponent wire [10:0] infinityres; // Infinity or max number @@ -75,9 +72,9 @@ module expgen(x[62:52], y[62:52], z[62:52], // if exponent is out of bounds - assign ae = x + y - 1023; + assign ae = xexp + yexp; - assign prodof = (ae > 2046 && ~ae[12]); + assign prodof = (ae - 1023 > 2046 && ~ae[12]); // Compute alignment shift count // Adjust for postrounding normalization of Z. @@ -85,22 +82,19 @@ module expgen(x[62:52], y[62:52], z[62:52], // check if a round overflows is shorter than the actual round and // is masked by the bypass mux and two 10 bit adder delays. - assign aligncnt0 = z - ae + 13'b0;// KEP use all of ae - assign aligncnt1 = z - ae + 13'b1; - //assign aligncnt0 = z - ae[10:0] + 13'b0;//original - //assign aligncnt1 = z - ae[10:0] + 13'b1; - assign aligncnt = bypsel[1] && byppostnorm ? aligncnt1 : aligncnt0; + assign aligncnt = zexp - ae;// KEP use all of ae + // Select exponent (usually from product except in case of huge addend) - assign be = killprod ? z : ae; + assign be = zexpsel ? zexp : ae; // Adjust exponent based on normalization // A compound adder takes care of the case of post-rounding normalization // requiring an extra increment - assign de0 = sumzero ? 13'b0 : be + 53 - normcnt; - assign de1 = sumzero ? 13'b0 : be + 53 - normcnt + 13'b1; + //assign de0 = sumzero ? 13'b0 : be + normcnt + 2; + // assign de1 = sumzero ? 13'b0 : be + normcnt + 2; // If the exponent becomes exactly zero (denormalized) // signal such to adjust R bit before rounding @@ -109,9 +103,9 @@ module expgen(x[62:52], y[62:52], z[62:52], // check for exponent out of bounds after add - assign de = postnormalize ? de1 : de0; - assign sumof = de > 2046 && ~de[12]; - assign sumuf = (de == 0 || de[12]) && ~sumzero && ~zdenorm;//KEP ~zdenorm to prevent underflow flag + assign de = resultdenorm ? 0 : de0; + assign sumof = de[12]; + assign sumuf = de == 0 && ~sumzero && ~resultdenorm; // bypass occurs before rounding or taking early results @@ -122,8 +116,7 @@ module expgen(x[62:52], y[62:52], z[62:52], // produces either infinity or the largest finite number, depending on the // rounding mode. NaNs are propagated or generated. - assign specialres = earlyressel ? earlyres : - invalid | nan ? nanres : // KEP added nan + assign specialres = invalid | nan ? nanres : // KEP added nan overflow ? infinityres : inf ? 11'b11111111111 : underflow ? 11'b0 : 11'bx; @@ -134,11 +127,11 @@ module expgen(x[62:52], y[62:52], z[62:52], // "If two or more inputs are NaN, then the payload of the resulting NaN should be // identical to the payload of one of the input NaNs if representable in the destination // format. This standard does not specify which of the input NaNs will provide the payload." - assign nanres = xnan ? x : (ynan ? y : (znan? z : 11'b11111111111)); + assign nanres = xnan ? xexp : (ynan ? yexp : (znan? zexp : 11'b11111111111)); // A mux selects the early result from other FPU blocks or the // normalized FMAC result. Special cases are also detected. - assign w = specialsel ? specialres[10:0] : de; + assign wexp = specialsel ? specialres[10:0] : de[10:0]; endmodule diff --git a/wally-pipelined/src/fpu/FMA/flag.v b/wally-pipelined/src/fpu/FMA/flag.sv similarity index 94% rename from wally-pipelined/src/fpu/FMA/flag.v rename to wally-pipelined/src/fpu/FMA/flag.sv index 901af488..b8a2dc74 100644 --- a/wally-pipelined/src/fpu/FMA/flag.v +++ b/wally-pipelined/src/fpu/FMA/flag.sv @@ -9,7 +9,7 @@ ///////////////////////////////////////////////////////////////////////////// module flag(xnan, ynan, znan, xinf, yinf, zinf, prodof, sumof, sumuf, - psign, zsign, xzero, yzero, v[1:0], + psign, zsign, xzero, yzero, vbits, inf, nan, invalid, overflow, underflow, inexact); ///////////////////////////////////////////////////////////////////////////// @@ -26,7 +26,7 @@ module flag(xnan, ynan, znan, xinf, yinf, zinf, prodof, sumof, sumuf, input zsign; // Sign of z input xzero; // x = 0 input yzero; // y = 0 - input [1:0] v; // R and S bits of result + input [1:0] vbits; // R and S bits of result output inf; // Some source is Inf output nan; // Some source is NaN output invalid; // Result is invalid @@ -81,6 +81,6 @@ module flag(xnan, ynan, znan, xinf, yinf, zinf, prodof, sumof, sumuf, // 2) Addition inexact // One of these cases occurred if the R or S bit is set - assign inexact = (v[0] || v[1] || suminf) && ~(inf || nan); + assign inexact = (vbits[0] || vbits[1] || suminf) && ~(inf || nan); endmodule diff --git a/wally-pipelined/src/fpu/FMA/fmac.sv b/wally-pipelined/src/fpu/FMA/fmac.sv new file mode 100644 index 00000000..0741d2b3 --- /dev/null +++ b/wally-pipelined/src/fpu/FMA/fmac.sv @@ -0,0 +1,138 @@ + //////////////////////////////////////////////////////////////////////////////// +// Block Name: fmac.v +// Author: David Harris +// Date: 11/2/1995 +// +// Block Description: +// This is the top level block of a floating-point multiply/accumulate +// unit(FMAC). It instantiates the following sub-blocks: +// +// array Booth encoding, partial product generation, product summation +// expgen Exponent summation, compare, and adjust +// align Alignment shifter +// add Carry-save adder for accumulate, carry propagate adder +// lza Leading zero anticipator to control normalization shifter +// normalize Normalization shifter +// round Rounding of result +// exception Handles exceptional cases +// bypass Handles bypass of result to X or Z inputs +// sign One bit sign handling block +// special Catch special cases (inputs = 0 / infinity / etc.) +// +// The FMAC computes W=X*Y+Z, rounded with the mode specified by +// RN, RZ, RM, or RP. The result is optionally bypassed back to +// the X or Z inputs for use on the next cycle. In addition, four signals +// are produced: trap, overflow, underflow, and inexact. Trap indicates +// an infinity, NaN, or denormalized number to be handled in software; +// the other three signals are IEEE flags. +// +///////////////////////////////////////////////////////////////////////////// + +///////////////////////////////////////////////////////////////////////////// +module fmac(x, y, z, rn, rz, rp, rm, + earlyres, earlyressel, bypsel, bypplus1, byppostnorm, + w, wbypass, invalid, overflow, underflow, inexact); +///////////////////////////////////////////////////////////////////////////// + + input [63:0] x; // input X from reg file + input [63:0] y; // input Y + input [63:0] z; // input Z from reg file + input rn; // Round to Nearest + input rz; // Round toward zero + input rm; // Round toward minus infinity + input rp; // Round toward plus infinity + input [63:0] earlyres; // Early result from other FP logic + input earlyressel; // Select early result, not W + input [1:0] bypsel; // Select W bypass to X, or z + input bypplus1; // Add one in bypass + input byppostnorm; // postnormalize in bypass + output [63:0] w; // output W=X*Y+Z + output [63:0] wbypass; // prerounded output W=X*Y+Z for bypass + output invalid; // Result is invalid + output overflow; // Result overflowed + output underflow; // Result underflowed + output inexact; // Result is not an exact number + +// Internal nodes + + logic [105:0] r; // one result of partial product sum + logic [105:0] s; // other result of partial products + logic [163:0] t; // output of alignment shifter + logic [163:0] sum; // output of carry prop adder + logic [53:0] v; // normalized sum, R, S bits + logic [11:0] aligncnt; // shift count for alignment + logic [8:0] normcnt; // shift count for normalizer + logic [12:0] ae; // multiplier expoent + logic bs; // sticky bit of addend + logic ps; // sticky bit of product + logic killprod; // Z >> product + logic negsum; // negate sum + logic invz; // invert addend + logic selsum1; // select +1 mode of sum + logic negsum0; // sum +0 < 0 + logic negsum1; // sum +1 < 0 + logic sumzero; // sum = 0 + logic infinity; // generate infinity on overflow + logic prodof; // X*Y out of range + logic sumof; // result out of range + logic xzero; + logic yzero; + logic zzero; + logic xdenorm; + logic ydenorm; + logic zdenorm; + logic proddenorm; + logic zexpsel; + logic denorm0; + logic resultdenorm; + logic inf; + logic xinf; + logic yinf; + logic zinf; + logic xnan; + logic ynan; + logic znan; + logic specialsel; + logic nan; + logic sumuf; + logic psign; + logic [8:0] sumshift; + logic [12:0] de0; + + + + + + + + + + + + + + +// Instantiate fraction datapath + + multiply multiply(.xman(x[51:0]), .yman(y[51:0]), .*); + align align(.zman(z[51:0]),.*); + add add(.*); + lza lza(.*); + normalize normalize(.zexp(z[62:52]),.*); + round round(.xman(x[51:0]), .yman(y[51:0]),.zman(z[51:0]), .wman(w[51:0]),.wsign(w[63]),.*); + +// Instantiate exponent datapath + + expgen expgen(.xexp(x[62:52]),.yexp(y[62:52]),.zexp(z[62:52]),.wexp(w[62:52]),.*); +// Instantiate special case detection across datapath & exponent path + + special special(.*); + + +// Instantiate control logic + +sign sign(.xsign(x[63]),.ysign(y[63]),.zsign(z[63]),.wsign(w[63]),.*); +flag flag(.zsign(z[63]),.vbits(v[1:0]),.*); + +endmodule + diff --git a/wally-pipelined/src/fpu/FMA/fmac.v b/wally-pipelined/src/fpu/FMA/fmac.v deleted file mode 100644 index 724a8933..00000000 --- a/wally-pipelined/src/fpu/FMA/fmac.v +++ /dev/null @@ -1,130 +0,0 @@ - //////////////////////////////////////////////////////////////////////////////// -// Block Name: fmac.v -// Author: David Harris -// Date: 11/2/1995 -// -// Block Description: -// This is the top level block of a floating-point multiply/accumulate -// unit(FMAC). It instantiates the following sub-blocks: -// -// array Booth encoding, partial product generation, product summation -// expgen Exponent summation, compare, and adjust -// align Alignment shifter -// add Carry-save adder for accumulate, carry propagate adder -// lza Leading zero anticipator to control normalization shifter -// normalize Normalization shifter -// round Rounding of result -// exception Handles exceptional cases -// bypass Handles bypass of result to X or Z inputs -// sign One bit sign handling block -// special Catch special cases (inputs = 0 / infinity / etc.) -// -// The FMAC computes W=X*Y+Z, rounded with the mode specified by -// RN, RZ, RM, or RP. The result is optionally bypassed back to -// the X or Z inputs for use on the next cycle. In addition, four signals -// are produced: trap, overflow, underflow, and inexact. Trap indicates -// an infinity, NaN, or denormalized number to be handled in software; -// the other three signals are IEEE flags. -// -///////////////////////////////////////////////////////////////////////////// - -///////////////////////////////////////////////////////////////////////////// -module fmac(xrf, y, zrf, rn, rz, rp, rm, - earlyres, earlyressel, bypsel, bypplus1, byppostnorm, - w, wbypass, invalid, overflow, underflow, inexact); -///////////////////////////////////////////////////////////////////////////// - - input [63:0] xrf; // input X from reg file - input [63:0] y; // input Y - input [63:0] zrf; // input Z from reg file - input rn; // Round to Nearest - input rz; // Round toward zero - input rm; // Round toward minus infinity - input rp; // Round toward plus infinity - input [63:0] earlyres; // Early result from other FP logic - input earlyressel; // Select early result, not W - input [1:0] bypsel; // Select W bypass to X, or z - input bypplus1; // Add one in bypass - input byppostnorm; // postnormalize in bypass - output [63:0] w; // output W=X*Y+Z - output [63:0] wbypass; // prerounded output W=X*Y+Z for bypass - output invalid; // Result is invalid - output overflow; // Result overflowed - output underflow; // Result underflowed - output inexact; // Result is not an exact number - -// Internal nodes - - wire [63:0] x; // input X after bypass mux - wire [63:0] z; // input Z after bypass mux - wire [105:0] r; // one result of partial product sum - wire [105:0] s; // other result of partial products - wire [157:0] t; // output of alignment shifter - wire [157:0] sum; // output of carry prop adder - wire [53:0] v; // normalized sum, R, S bits - wire [11:0] aligncnt; // shift count for alignment - wire [8:0] normcnt; // shift count for normalizer - wire [12:0] ae; // multiplier expoent - wire bs; // sticky bit of addend - wire ps; // sticky bit of product - wire killprod; // Z >> product - wire negsum; // negate sum - wire invz; // invert addend - wire selsum1; // select +1 mode of sum - wire negsum0; // sum +0 < 0 - wire negsum1; // sum +1 < 0 - wire sumzero; // sum = 0 - wire infinity; // generate infinity on overflow - wire prodof; // X*Y out of range - wire sumof; // result out of range - -// Instantiate fraction datapath - - array array(x[51:0], y[51:0], xdenorm, ydenorm, r[105:0], s[105:0], - bypsel[0], bypplus1); - align align(z[51:0], ae, aligncnt, xzero, yzero, zzero, zdenorm, proddenorm, - t[157:0], bs, ps, killprod, - bypsel[1], bypplus1, byppostnorm); - add add(r[105:0], s[105:0], t[157:0], sum[157:0], - negsum, invz, selsum1, killprod, negsum0, negsum1, proddenorm); - lop lop(sum, normcnt, sumzero); - normalize normalize(sum[157:0], normcnt, sumzero, bs, ps, denorm0, zdenorm, - v[53:0]); - round round(v[53:0], earlyres[51:0], earlyressel, rz, rn, rp, rm, w[63], - invalid, overflow, underflow, inf, nan, xnan, ynan, znan, - x[51:0], y[51:0], z[51:0], - w[51:0], postnorrnalize, infinity, specialsel); - bypass bypass(xrf[63:0], zrf[63:0], wbypass[63:0], bypsel[1:0], - x[63:0], z[63:0]); - -// Instantiate exponent datapath - - expgen expgen(x[62:52], y[62:52], z[62:52], - earlyres[62:52], earlyressel, bypsel[1], byppostnorm, - killprod, sumzero, postnorrnalize, normcnt, - infinity, invalid, overflow, underflow, - inf, nan, xnan, ynan, znan, zdenorm, proddenorm, specialsel, - aligncnt, w[62:52], wbypass[62:52], - prodof, sumof, sumuf, denorm0, ae); -// Instantiate special case detection across datapath & exponent path - - special special(x[63:0], y[63:0], z[63:0], ae, xzero, yzero, zzero, - xnan, ynan, znan, xdenorm, ydenorm, zdenorm, proddenorm, - xinf, yinf, zinf); - -// Produce W for bypass - -assign wbypass[51:0] = v[53:2]; -assign wbypass[63] = w[63]; - -// Instantiate control logic - -sign sign(x[63], y[63], z[63], negsum0, negsum1, bs, ps, - killprod, rm, overflow, sumzero, nan, invalid, xinf, yinf, zinf, inf, - w[63], invz, negsum, selsum1, psign); -flag flag(xnan, ynan, znan, xinf, yinf, zinf, prodof, sumof, sumuf, - psign, z[63], xzero, yzero, v[1:0], - inf, nan, invalid, overflow, underflow, inexact); - -endmodule - diff --git a/wally-pipelined/src/fpu/FMA/lop.v b/wally-pipelined/src/fpu/FMA/lza.sv similarity index 88% rename from wally-pipelined/src/fpu/FMA/lop.v rename to wally-pipelined/src/fpu/FMA/lza.sv index af496dfc..8b53d0fe 100644 --- a/wally-pipelined/src/fpu/FMA/lop.v +++ b/wally-pipelined/src/fpu/FMA/lza.sv @@ -9,10 +9,10 @@ /////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// -module lop(sum, normcnt, sumzero); +module lza(sum, normcnt, sumzero); ///////////////////////////////////////////////////////////////////////////// - input [157:0] sum; // sum + input [163:0] sum; // sum output [8:0] normcnt; // normalization shift count output sumzero; // sum = 0 @@ -30,7 +30,7 @@ module lop(sum, normcnt, sumzero); always @ ( sum) begin i = 0; - while (~sum[157-i] && i < 157) i = i+1; // search for leading one + while (~sum[108-i] && i < 108) i = i+1; // search for leading one normcnt = i; // compute shift count end diff --git a/wally-pipelined/src/fpu/FMA/multiply.sv b/wally-pipelined/src/fpu/FMA/multiply.sv new file mode 100644 index 00000000..5204c00d --- /dev/null +++ b/wally-pipelined/src/fpu/FMA/multiply.sv @@ -0,0 +1,15 @@ + +module multiply(xman, yman, xdenorm, ydenorm, r, s); +///////////////////////////////////////////////////////////////////////////// + + input [51:0] xman; // Fraction of multiplicand x + input [51:0] yman; // Fraction of multiplicand y + input xdenorm; // is x denormalized + input ydenorm; // is y denormalized + output [105:0] r; // partial product 1 + output [105:0] s; // partial product 2 + + assign r = 106'b0; + assign s = {53'b0,~xdenorm,xman} * {53'b0,~ydenorm,yman}; + +endmodule diff --git a/wally-pipelined/src/fpu/FMA/normalize.v b/wally-pipelined/src/fpu/FMA/normalize.sv similarity index 59% rename from wally-pipelined/src/fpu/FMA/normalize.v rename to wally-pipelined/src/fpu/FMA/normalize.sv index 3ad8752d..ff50daf7 100644 --- a/wally-pipelined/src/fpu/FMA/normalize.v +++ b/wally-pipelined/src/fpu/FMA/normalize.sv @@ -14,21 +14,30 @@ ///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// -module normalize(sum[157:0], normcnt, sumzero, bs, ps, denorm0, zdenorm, v[53:0]); +module normalize(sum, zexp, normcnt, ae, aligncnt, sumshift, sumzero, bs, ps, denorm0, zdenorm, de0, resultdenorm, v); ///////////////////////////////////////////////////////////////////////////// - input [157:0] sum; // sum + input [163:0] sum; // sum + input [62:52] zexp; // sum input [8:0] normcnt; // normalization shift count + input [12:0] ae; // normalization shift count + input [11:0] aligncnt; // normalization shift count + input [8:0] sumshift; // normalization shift count input sumzero; // sum is zero input bs; // sticky bit for addend input ps; // sticky bit for product input denorm0; // exponent = -1023 input zdenorm; // Input Z is denormalized + output [12:0] de0; + output resultdenorm; // Input Z is denormalized output [53:0] v; // normalized sum, R, S bits // Internal nodes reg [53:0] v; // normalized sum, R, S bits - wire [157:0] sumshifted; // shifted sum + logic resultdenorm; // Input Z is denormalized + logic [12:0] de0; + logic [163:0] sumshifted; // shifted sum +logic tmp; // When the sum is zero, normalization does not apply and only the // sticky bit must be computed. Otherwise, the sum is right-shifted @@ -41,23 +50,33 @@ module normalize(sum[157:0], normcnt, sumzero, bs, ps, denorm0, zdenorm, v[53:0] // The sticky bit calculation is actually built into the shifter and // does not require a true subtraction shown in the model. - always @(sum or normcnt or sumzero or bs or ps or sumshifted or denorm0) + assign tmp = ($signed(ae-normcnt+2) >= $signed(-1022)); + always @(sum or normcnt or sumshift or ae or aligncnt) begin - if (sumzero) begin // special case - v[53:1] = 0; - v[0] = ps || bs ; + if ($signed(aligncnt)<=$signed(2)) begin // special case + if ($signed(ae-normcnt+2) >= $signed(-1022)) begin + sumshifted = sum << (55+normcnt); + v = sumshifted[157:104]; + resultdenorm = 0; + de0 = ae-normcnt+2; + end else begin + sumshifted = sum << (1079+ae); + v = sumshifted[157:104]; + resultdenorm = 1; + de0 = 0; + end + end else begin // extract normalized bits - v[53:3] = sumshifted[156:106]; - // KEP prevent plus1 in round.v when z is denormalized. - v[2] = sumshifted[105] || sumshifted[106] && denorm0 && ~zdenorm; - v[1] = sumshifted[104] || sumshifted[105] && denorm0 && ~zdenorm; - v[0] = |(sumshifted[103:0]) || ps || bs; + sumshifted = sum << sumshift; + v = sumshifted[157:104]; + resultdenorm = 0; + de0 = zexp; end end // shift sum left by normcnt, filling the right with zeros - assign sumshifted = sum << normcnt; + //assign sumshifted = sum << normcnt; endmodule diff --git a/wally-pipelined/src/fpu/FMA/round.v b/wally-pipelined/src/fpu/FMA/round.sv similarity index 81% rename from wally-pipelined/src/fpu/FMA/round.v rename to wally-pipelined/src/fpu/FMA/round.sv index a4e4e1cd..0472ffd0 100644 --- a/wally-pipelined/src/fpu/FMA/round.v +++ b/wally-pipelined/src/fpu/FMA/round.sv @@ -13,15 +13,13 @@ ///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// -module round(v[53:0], earlyres[51:0], earlyressel, rz, rn, rp, rm, wsign, +module round(v, rz, rn, rp, rm, wsign, invalid, overflow, underflow, inf, nan, xnan, ynan, znan, - x[51:0], y[51:0], z[51:0], - w[51:0], postnormalize, infinity, specialsel); + xman, yman, zman, + wman, infinity, specialsel); ///////////////////////////////////////////////////////////////////////////// input [53:0] v; // normalized sum, R, S bits - input [51:0] earlyres; // result from other FPU blocks - input earlyressel; // use result from other FPU blocks input rz; // Round toward zero input rn; // Round toward nearest input rp; // Round toward plus infinity @@ -35,11 +33,11 @@ module round(v[53:0], earlyres[51:0], earlyressel, rz, rn, rp, rm, wsign, input xnan; // X is NaN input ynan; // Y is NaN input znan; // Z is NaN - input [51:0] x; // Input X - input [51:0] y; // Input Y - input [51:0] z; // Input Z - output [51:0] w; // rounded result of FMAC - output postnormalize; // Right shift 1 for post-rounding norm + input [51:0] xman; // Input X + input [51:0] yman; // Input Y + input [51:0] zman; // Input Z + output [51:0] wman; // rounded result of FMAC + //output postnormalize; // Right shift 1 for post-rounding norm output infinity; // Generate infinity on overflow output specialsel; // Select special result @@ -64,7 +62,7 @@ module round(v[53:0], earlyres[51:0], earlyressel, rz, rn, rp, rm, wsign, // Determine if postnormalization is necessary // Predicted by all bits =1 before round +1 - assign postnormalize = &(v[53:2]) && plus1; + //assign postnormalize = &(v[53:2]) && plus1; // Determine special result in event of of selection of a result from // another FPU functional unit, infinity, NAN, or underflow @@ -74,10 +72,9 @@ module round(v[53:0], earlyres[51:0], earlyressel, rz, rn, rp, rm, wsign, // inputs to the wide muxes can be combined at the expense of more // complicated non-critical control in the circuit implementation. - assign specialsel = earlyressel || overflow || underflow || invalid || + assign specialsel = overflow || underflow || invalid || nan || inf; - assign specialres = earlyressel ? earlyres : - invalid | nan ? nanres : //KEP added nan + assign specialres = invalid | nan ? nanres : //KEP added nan overflow ? infinityres : inf ? 52'b0 : underflow ? 52'b0 : 52'bx; // default to undefined @@ -98,14 +95,14 @@ module round(v[53:0], earlyres[51:0], earlyressel, rz, rn, rp, rm, wsign, // "If two or more inputs are NaN, then the payload of the resulting NaN should be // identical to the payload of one of the input NaNs if representable in the destination // format. This standard does not specify which of the input NaNs will provide the payload." - assign nanres = xnan ? {1'b1, x[50:0]}: (ynan ? {1'b1, y[50:0]} : (znan ? {1'b1, z[50:0]} : {1'b1, 51'b0}));// KEP 210112 add the 1 to make NaNs quiet + assign nanres = xnan ? {1'b1, xman[50:0]}: (ynan ? {1'b1, yman[50:0]} : (znan ? {1'b1, zman[50:0]} : {1'b1, 51'b0}));// KEP 210112 add the 1 to make NaNs quiet // Select result with 4:1 mux // If the sum is zero and we round up, there is a special case in // which we produce a massive loss of significance and trap to software. // It is handled in the exception unit. - assign w = specialsel ? specialres : (plus1 ? v1[51:0] : v[53:2]); + assign wman = specialsel ? specialres : (plus1 ? v1[51:0] : v[53:2]); endmodule diff --git a/wally-pipelined/src/fpu/FMA/sign.v b/wally-pipelined/src/fpu/FMA/sign.sv similarity index 97% rename from wally-pipelined/src/fpu/FMA/sign.v rename to wally-pipelined/src/fpu/FMA/sign.sv index 48fd716f..c14698ca 100644 --- a/wally-pipelined/src/fpu/FMA/sign.v +++ b/wally-pipelined/src/fpu/FMA/sign.sv @@ -43,6 +43,7 @@ module sign(xsign, ysign, zsign, negsum0, negsum1, bs, ps, killprod, rm, overflo wire infsign; // sign if result= Inf reg negsum; // negate result of adder reg selsum1; // select +1 mode from compound adder +logic tmp; // Compute sign of product @@ -89,6 +90,7 @@ module sign(xsign, ysign, zsign, negsum0, negsum1, bs, ps, killprod, rm, overflo assign zerosign = (~invz && killprod) ? zsign : rm; assign infsign = zinf ? zsign : psign; //KEP 210112 keep the correct sign when result is infinity //assign infsign = xinf ? (yinf ? psign : xsign) : yinf ? ysign : zsign;//original + assign tmp = invalid ? 0 : (inf ? infsign :(sumzero ? zerosign : psign ^ negsum)); assign wsign = invalid ? 0 : (inf ? infsign :(sumzero ? zerosign : psign ^ negsum)); endmodule diff --git a/wally-pipelined/src/fpu/FMA/special.v b/wally-pipelined/src/fpu/FMA/special.sv similarity index 97% rename from wally-pipelined/src/fpu/FMA/special.v rename to wally-pipelined/src/fpu/FMA/special.sv index f2201f5c..89894ca9 100644 --- a/wally-pipelined/src/fpu/FMA/special.v +++ b/wally-pipelined/src/fpu/FMA/special.sv @@ -10,7 +10,7 @@ ///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// -module special(x[63:0], y[63:0], z[63:0], ae, xzero, yzero, zzero, +module special(x, y, z, ae, xzero, yzero, zzero, xnan, ynan, znan, xdenorm, ydenorm, zdenorm, proddenorm, xinf, yinf, zinf); ///////////////////////////////////////////////////////////////////////////// diff --git a/wally-pipelined/src/fpu/FMA/tb.v b/wally-pipelined/src/fpu/FMA/tb.v deleted file mode 100644 index a28e3c4d..00000000 --- a/wally-pipelined/src/fpu/FMA/tb.v +++ /dev/null @@ -1,2824 +0,0 @@ -`timescale 1 ns/10 ps -module tb; - - - reg [63:0] xrf; - reg [63:0] y; - reg [63:0] zrf; - reg rn; - reg rz; - reg rm; - reg rp; - reg [63:0] earlyres; - reg earlyressel; - reg [1:0] bypsel; - reg bypplus1; - reg byppostnorm; - wire [63:0] w; - wire [63:0] wbypass; - wire invalid; - wire overflow; - wire underflow; - wire inexact; - -reg [5:0] i; -integer fp; - -localparam period = 20; -fmac UUT(.xrf(xrf), .y(y), .zrf(zrf), .rn(rn), .rz(rz), .rp(rp), .rm(rm), - .earlyres(earlyres), .earlyressel(earlyressel), .bypsel(bypsel), .bypplus1(bypplus1), .byppostnorm(byppostnorm), - .w(w), .wbypass(wbypass), .invalid(invalid), .overflow(overflow), .underflow(underflow), .inexact(inexact)); - - -initial - begin -fp = $fopen("output","w"); - xrf = 64'hc22000007fffffff; - y = 64'h24700000ffffffef; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hbfc00000000011fe; - y = 64'h3fdfffffffffff03; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'ha83100000007fffe; - y = 64'h41e0000effffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'h001ffffffffffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h400327ca64d70ec7; - y = 64'h3ca0000000000001; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'h43e207ffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'h3fd0000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'h3fdfffffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'h3fe0000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc870200000010000; - y = 64'h3fefffffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc00aaa4fd557ef13; - y = 64'hc3b8917384eb32d0; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'h7ffc000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'hc18aca47203438e2; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'h4000000000000001; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h47efff0008000000; - y = 64'hb1dcb0523546117f; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h43f000ffffff7fff; - y = 64'h22300000001fffdf; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h402ff000001fffff; - y = 64'h40759558e27de226; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'h40efdeffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'h434fffffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h7ffc000000000000; - y = 64'h7fe0000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hb35e061abc769f3a; - y = 64'hc078000003fffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h403a793cfb1e2471; - y = 64'hbff0000100007fff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h3d1ffffbfe000000; - y = 64'h216898822a24af3f; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hbfb00000001bffff; - y = 64'h7ffc000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h37f0000000efffff; - y = 64'hc3d00007fffffeff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'hffefff8000080000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h3fb00200000000ff; - y = 64'hc0000000011fffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h41c0000007ffffff; - y = 64'h49103fffefffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h407effbfffffffff; - y = 64'h3e00000040001fff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc1f00013fffffffe; - y = 64'h7ffc000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc3f00004000001ff; - y = 64'hc3d00bfffffffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h403b5ab30b28be12; - y = 64'hbfdfffffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'hc1cfffffff87ffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'hbfe0000000000001; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h801ffc000007ffff; - y = 64'hbfeffffffffffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'hffe0000005fffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'hbfffffffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'hc000000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc3d09308769f3f51; - y = 64'hc00fffffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'h402ffffdfefffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'hc010000000000001; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc01fffffffc00fff; - y = 64'hc01ffffffffffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc025e14360f49046; - y = 64'h412fff0000000003; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'h43ee59a2f1155c8b; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h3fe0000000008fff; - y = 64'h802ffffff7fffff6; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'hffefffffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h40401007fffffffe; - y = 64'hfff0000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'hc0045abb4860cbf3; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0000000000000000; - y = 64'h7ffc000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hbffffffec0000000; - y = 64'hc000000000003eff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h48000000004001ff; - y = 64'h41f331de979ac49e; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h3d0fffffbff7ffff; - y = 64'h7ffc000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h43d3ffffff000000; - y = 64'h3caffffffffffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h7ffc000000000000; - y = 64'h43dfff8004000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hbcaffe0000000008; - y = 64'h3fd00008000000ff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h404ffbfffffffffc; - y = 64'hc34ffff8003fffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h43e0000000000082; - y = 64'h3db000003ffffeff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc1d004000ffffffe; - y = 64'h4000000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc00fffffc000007e; - y = 64'hc02ffffdfffffbff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h409dfffbffffffff; - y = 64'h4010000000000001; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc120000003ffffe0; - y = 64'hc06000fffbffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h3fd1f7ffffffffff; - y = 64'hc01000001dffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h2e0fefdfffffffff; - y = 64'h4030000020000040; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h43c0000803ffffff; - y = 64'h3fcfffffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc0afffffbffffdfe; - y = 64'h3fc07ffdffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc0fffffffeffffee; - y = 64'h55139bb9349e058c; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h41ffdbaf18ce06bd; - y = 64'h8010000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc0e1000000080000; - y = 64'h801ffffffffffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h3fbffffff0000007; - y = 64'hc807dfffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc357b53537b96da5; - y = 64'hbfd0000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h401fffffffffffff; - y = 64'hffebff8000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc7eff77bf2b59c3c; - y = 64'hbfe0000000000001; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h380c3f72cc3dec98; - y = 64'hc3fffffffbffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hb8e0000003fbffff; - y = 64'hc503f4d44f4bf888; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h3f3ffffc001fffff; - y = 64'hc000000000000001; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc340002000004000; - y = 64'hc0db3367e0423019; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h4f60000801ffffff; - y = 64'h41c07fe000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc1ffffffbfefffff; - y = 64'hc340000000000001; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h404fff7fffffff7f; - y = 64'h48ab7e2aad4ec686; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h7ffc000000000000; - y = 64'hffefffffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h41e189ea1a6fff97; - y = 64'h7ffc000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h3ff0ee9046c9330f; - y = 64'h8479e1e79766e02b; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hd2f805130a8c11df; - y = 64'h43effffdfdfffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h4f1fffbfffe00000; - y = 64'hbcd02000000007ff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hbe70000077ffffff; - y = 64'hc1efffffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h41e1ffffbffffffe; - y = 64'h3caffffffffffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h3bbd976272fb1d2a; - y = 64'hc06ffff80007fffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h434fff01ffffffff; - y = 64'h403dfeffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hbe6fff7fffffffff; - y = 64'h3feffffffffffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h41d007ff80000000; - y = 64'h41f0fffffffc0000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hffeef7a206029708; - y = 64'hbdcfa4109a3a5b22; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h3b6ffffffeffffc0; - y = 64'h3c7ffffe003ffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc1d1ffffffbfffff; - y = 64'hbfcffffefffff800; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h2030000000000090; - y = 64'hc05e2e90015c47a1; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hbbf000000007efff; - y = 64'h001fe0000007fffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h41cae866712069f4; - y = 64'hc02fffffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hbfce1e32ccf56348; - y = 64'h3ca1f66d4c8eeef3; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hffedfffff0000000; - y = 64'hffeffff000000800; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h37effffc3ffffffe; - y = 64'hbca0fffffffffffd; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hbc950a021bf9dee1; - y = 64'h3db0001fffdffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hfd4fffffdfffffef; - y = 64'h41cffffdffffffef; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hbfc00000004007ff; - y = 64'hbcafffffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc009130b80fe8274; - y = 64'hb811571307061a38; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc0600000ffffffdf; - y = 64'h7feda1b8c591f9c6; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc1e4af3f8d45e031; - y = 64'h3ca0020002000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h3800008100000000; - y = 64'hb810000020000080; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h372ff00000003fff; - y = 64'h7fe000fdfffffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h47d00021fffffffe; - y = 64'hc00fffffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hbfbc9ea0c2b4884b; - y = 64'h43f4a552574073d5; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hbf1fe0000000ffff; - y = 64'hc01ffffffffffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h41ffffffff7ffffb; - y = 64'h0027ffffffffeffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc7e040000fffffff; - y = 64'hffe0000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h7ffc000000000000; - y = 64'h3fe0000ffffff7ff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc1effc1fffffffff; - y = 64'h7ffc000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc0d000000001ffbf; - y = 64'hc03ba46e644e4e9c; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc4500000005fffff; - y = 64'hc03a20ab4de47fc9; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h400e00000000007e; - y = 64'h001fffffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h45a01fffff7fffff; - y = 64'hc3c0020200000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h3e8ff800000000ff; - y = 64'h3caffffffffffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hbe004000000007fe; - y = 64'h3fdffff7ff7fffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hb11000007ffffe00; - y = 64'h3fe0000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hb80cef50bd17db40; - y = 64'hc05fffc00000000e; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h3d4000ffffffffff; - y = 64'h3d47f68d8eb6b9a4; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hffe3fffffffffffb; - y = 64'hc03dc3321aaa5380; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h3ca3fffffffffeff; - y = 64'hbf02ffafb4e9241d; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h53598c812c3c39dd; - y = 64'h3f20000100fffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc3dffffff8000001; - y = 64'h3fe0020000003ffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h7ba00800003fffff; - y = 64'h3ff9a9a129c791b3; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc3d0000fffffffef; - y = 64'h7fe0000000000001; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc34f80001fffffff; - y = 64'hb7fffffe0007ffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0010000000001ff8; - y = 64'h4800020000010000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h2c4c0000003fffff; - y = 64'h230ffffc00400000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h381fffffffbff7fe; - y = 64'h8010000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h802d3018ea8c241d; - y = 64'hc007fdffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h43e047fffffffffe; - y = 64'h4000003ffdfffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc000005fffffffff; - y = 64'h403ffffffff00002; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h3fc8b60e46a80f6d; - y = 64'hbfdffffffffffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hbd5fdffdffffffff; - y = 64'h5644b72ace1bbb6b; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hb80010001fffffff; - y = 64'h40e01ffffff7fffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h407000003ffbfffe; - y = 64'h38042862fe8e3368; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hbf8ffbfff7ffffff; - y = 64'hc00fffffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hbcafc000003fffff; - y = 64'hc010000000000001; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h47eddf042473ef08; - y = 64'hb7e00000fe000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h3fbfffff7fffffef; - y = 64'hc340ffffffffffbf; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc02f8000000007ff; - y = 64'hffe0000000000001; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h002f37ebf6c8eaec; - y = 64'hc08be464f4c81c69; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc00e800000000000; - y = 64'h7ffc000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0010000000000000; - y = 64'h0000000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hbfffc00000000003; - y = 64'h391001ffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc1db54446247aa52; - y = 64'hbfcc001fffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0010000000000000; - y = 64'hc0392c59c8e48f37; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0010000000000000; - y = 64'hc0000800000001ff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0010000000000000; - y = 64'hc1d0000004000fff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h4030040000200000; - y = 64'h0017055f48beeff5; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hbc7000000000ffee; - y = 64'hc1e0001100000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc040000000007fff; - y = 64'hc3b2a6c91c557f56; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h41ffffffff003fff; - y = 64'hc3b0000007ffffee; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h21900001dfffffff; - y = 64'hbf20000017fffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0029954d0f0df5b3; - y = 64'h41e00000000003ff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hb810000020000001; - y = 64'h47ffdfffffffff80; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0010000000000000; - y = 64'hffeffff800007fff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0010000000000000; - y = 64'h4010000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hbf700000000100ff; - y = 64'h401fffffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h37feffffffffffff; - y = 64'h47ef8000000fffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hb80f800001fffffe; - y = 64'h44e00000ffff7fff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0010000000000000; - y = 64'h434ffffffffffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h41ffffdfffff8000; - y = 64'h7fe0000000000001; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hb80a16ad02c87cd3; - y = 64'h380fffffffffe7fe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h47f0fffffffffffb; - y = 64'h7ffc000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0010000000000000; - y = 64'h41ffffffffbfff7f; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0010000000000000; - y = 64'h8000000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc3d00001000001ff; - y = 64'hb7f60cb3edb38762; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0010000000000000; - y = 64'h8010000000000001; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h43c0007fffdfffff; - y = 64'h801ffffffffffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc7efffffdffffbff; - y = 64'hbca0000000000001; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0010000000000000; - y = 64'hc11ff00000000003; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0010000000000000; - y = 64'hbfd0000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc0ffffffffeffffe; - y = 64'hbfdfffffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h6f7000000001fdff; - y = 64'h1510010000000fff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h37f002000000000f; - y = 64'hb1effcfffffffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hcc3050bc013d7cd7; - y = 64'hbff0000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0010000000000000; - y = 64'h87fff0000000fffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0010000000000000; - y = 64'hbffffffffffffffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h43effbfffffff7ff; - y = 64'h7fefffffff801ffe; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc015834380f2b995; - y = 64'h3f9fff0000000400; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0010000000000000; - y = 64'h41dfffffc0001000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0010000000000000; - y = 64'hc01fffffffffffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h41e010000000001f; - y = 64'hc5b04000000fffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h3b40018000000000; - y = 64'h3ea0400000000100; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0010000000000000; - y = 64'h4cdffeffff7fffff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h16dff0001ffffffe; - y = 64'h3fb500ae0796659d; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hb7e003ffffffff7f; - y = 64'hdeafffffeffffffd; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h406000001fffbfff; - y = 64'h3f20020000080000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h0010000000000000; - y = 64'h7ffc000000000000; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h439fbffffffbffff; - y = 64'hbf8454fd38ef0ba0; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hc1c000000200007e; - y = 64'hbf000001ffffffbf; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h480000000008fffe; - y = 64'h001637e790e69de2; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'hbffffffc000003fe; - y = 64'h3ca0000000000001; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - xrf = 64'h6b4848a9a8c0dcd5; - y = 64'h480ffffffffbdfff; - zrf = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - $fwrite(fp, "%h %h %h\n",xrf,y,w); - $stop; - end -endmodule \ No newline at end of file diff --git a/wally-pipelined/src/fpu/FMA/tbgen/ans b/wally-pipelined/src/fpu/FMA/tbgen/ans deleted file mode 100644 index a915aa9a..00000000 --- a/wally-pipelined/src/fpu/FMA/tbgen/ans +++ /dev/null @@ -1,199 +0,0 @@ -c22000007fffffff 24700000ffffffef a6a00001800007ed -bfc00000000011fe 3fdfffffffffff03 bfb000000000117f -a83100000007fffe 41e0000effffffff aa21000ff0080004 -0000000000000000 001ffffffffffffe 0000000000000000 -400327ca64d70ec7 3ca0000000000001 3cb327ca64d70ec9 -0000000000000000 43e207ffffffffff 0000000000000000 -0000000000000000 3fd0000000000000 0000000000000000 -0000000000000000 3fdfffffffffffff 0000000000000000 -0000000000000000 3fe0000000000000 0000000000000000 -c870200000010000 3fefffffffffffff c87020000000ffff -c00aaa4fd557ef13 c3b8917384eb32d0 43d478efdc9216d8 -0000000000000000 7ffc000000000000 7ff8000000000000 -0000000000000000 c18aca47203438e2 0000000000000000 -0000000000000000 4000000000000001 0000000000000000 -47efff0008000000 b1dcb0523546117f b9dcaf6cb9e07bdb -43f000ffffff7fff 22300000001fffdf 26300100001f81de -402ff000001fffff 40759558e27de226 40b58a8e3622388e -0000000000000000 40efdeffffffffff 0000000000000000 -0000000000000000 434fffffffffffff 0000000000000000 -7ffc000000000000 7fe0000000000000 7ff8000000000000 -b35e061abc769f3a c078000003fffffe 33e684941119bac2 -403a793cfb1e2471 bff0000100007fff c03a793ea2b2c7eb -3d1ffffbfe000000 216898822a24af3f 1e98987f158ae1d8 -bfb00000001bffff 7ffc000000000000 7ff8000000000000 -37f0000000efffff c3d00007fffffeff bbd0000800efff75 -0000000000000000 ffefff8000080000 0000000000000000 -3fb00200000000ff c0000000011fffff bfc00200012024fd -41c0000007ffffff 49103fffefffffff 4ae03ffff81ffff6 -407effbfffffffff 3e00000040001fff 3e8effc07bff3dfd -c1f00013fffffffe 7ffc000000000000 7ff8000000000000 -c3f00004000001ff c3d00bfffffffffe 47d00c04030001ff -403b5ab30b28be12 bfdfffffffffffff c02b5ab30b28be11 -0000000000000000 c1cfffffff87ffff 0000000000000000 -0000000000000000 bfe0000000000001 0000000000000000 -801ffc000007ffff bfeffffffffffffe 001ffc000007fffe -0000000000000000 ffe0000005fffffe 0000000000000000 -0000000000000000 bfffffffffffffff 0000000000000000 -0000000000000000 c000000000000000 0000000000000000 -c3d09308769f3f51 c00fffffffffffff 43f09308769f3f51 -0000000000000000 402ffffdfefffffe 0000000000000000 -0000000000000000 c010000000000001 0000000000000000 -c01fffffffc00fff c01ffffffffffffe 404fffffffc00ffe -c025e14360f49046 412fff0000000003 c165e09456d988a3 -0000000000000000 43ee59a2f1155c8b 0000000000000000 -3fe0000000008fff 802ffffff7fffff6 801ffffff8011ff3 -0000000000000000 ffefffffffffffff 0000000000000000 -40401007fffffffe fff0000000000000 80401007fffffffe -0000000000000000 c0045abb4860cbf3 0000000000000000 -0000000000000000 7ffc000000000000 7ff8000000000000 -bffffffec0000000 c000000000003eff 400ffffec0007dfe -48000000004001ff 41f331de979ac49e 4a0331de97e78e7e -3d0fffffbff7ffff 7ffc000000000000 7ff8000000000000 -43d3ffffff000000 3caffffffffffffe 4093fffffeffffff -7ffc000000000000 43dfff8004000000 7ff8000000000000 -bcaffe0000000008 3fd00008000000ff bc8ffe0fff000205 -404ffbfffffffffc c34ffff8003fffff c3affbf8013ff7fb -43e0000000000082 3db000003ffffeff 41a000003fffff82 -c1d004000ffffffe 4000000000000000 c1e004000ffffffe -c00fffffc000007e c02ffffdfffffbff 404ffffdc000007e -409dfffbffffffff 4010000000000001 40bdfffc00000001 -c120000003ffffe0 c06000fffbffffff 4190010000003fde -3fd1f7ffffffffff c01000001dffffff bff1f80021b0fffd -2e0fefdfffffffff 4030000020000040 2e4fefe03fdfc07f -43c0000803ffffff 3fcfffffffffffff 43a0000803ffffff -c0afffffbffffdfe 3fc07ffdffffffff c0807ffddf0002f5 -c0fffffffeffffee 55139bb9349e058c d6239bb9340127b7 -41ffdbaf18ce06bd 8010000000000000 821fdbaf18ce06bd -c0e1000000080000 801ffffffffffffe 011100000007ffff -3fbffffff0000007 c807dfffffffffff c7d7dffff4100004 -c357b53537b96da5 bfd0000000000000 4337b53537b96da5 -401fffffffffffff ffebff8000000000 801bff7fffffffff -c7eff77bf2b59c3c bfe0000000000001 47dff77bf2b59c3e -380c3f72cc3dec98 c3fffffffbffffff bc1c3f72c8b5fe3d -b8e0000003fbffff c503f4d44f4bf888 3df3f4d454443066 -3f3ffffc001fffff c000000000000001 bf4ffffc00200000 -c340002000004000 c0db3367e0423019 442b339e47125d6b -4f60000801ffffff 41c07fe000000000 51307fe841fffbff -c1ffffffbfefffff c340000000000001 454fffffbff00001 -404fff7fffffff7f 48ab7e2aad4ec686 490b7dbcb4a410dd -7ffc000000000000 ffefffffffffffff 7ff8000000000000 -41e189ea1a6fff97 7ffc000000000000 7ff8000000000000 -3ff0ee9046c9330f 8479e1e79766e02b 847b63d14ff91acb -d2f805130a8c11df 43effffdfdfffffe d6f8051188ba9004 -4f1fffbfffe00000 bcd02000000007ff cc001fdfbfefe7fe -be70000077ffffff c1efffffffffffff 4070000077ffffff -41e1ffffbffffffe 3caffffffffffffe 3ea1ffffbffffffd -3bbd976272fb1d2a c06ffff80007fffe bc3d975b0d29e641 -434fff01ffffffff 403dfeffffffffff 439dfe11e7efffff -be6fff7fffffffff 3feffffffffffffe be6fff7ffffffffd -41d007ff80000000 41f0fffffffc0000 43d1087f77fbfe01 -ffeef7a206029708 bdcfa4109a3a5b22 7dce9eaa2542875b -3b6ffffffeffffc0 3c7ffffe003ffffe 37fffffdff3fffce -c1d1ffffffbfffff bfcffffefffff800 41b1ffff6fbffb82 -2030000000000090 c05e2e90015c47a1 a09e2e90015c48b0 -bbf000000007efff 001fe0000007fffe fc1fe0000017d01c -41cae866712069f4 c02fffffffffffff c20ae866712069f3 -bfce1e32ccf56348 3ca1f66d4c8eeef3 bc80e7fa025544da -ffedfffff0000000 ffeffff000000800 3fedfff0f0000f80 -37effffc3ffffffe bca0fffffffffffd b4a0fffe01fffffb -bc950a021bf9dee1 3db0001fffdffffe ba550a2c2fd402cd -fd4fffffdfffffef 41cffffdffffffef ff2ffffde00001de -bfc00000004007ff bcafffffffffffff 3c800000004007ff -c009130b80fe8274 b811571307061a38 382b2cb1993b60f3 -c0600000ffffffdf 7feda1b8c591f9c6 805da1ba9fad85e2 -c1e4af3f8d45e031 3ca0020002000000 be94b1d577cd70de -3800008100000000 b810000020000080 b020008120010280 -372ff00000003fff 7fe000fdfffffffe 771ff1fb02003fff -47d00021fffffffe c00fffffffffffff c7f00021fffffffd -bfbc9ea0c2b4884b 43f4a552574073d5 c3c277000b21a4e7 -bf1fe0000000ffff c01ffffffffffffe 3f4fe0000000fffe -41ffffffff7ffffb 0027ffffffffeffe 0237ffffff9feffb -c7e040000fffffff ffe0000000000000 07d040000fffffff -7ffc000000000000 3fe0000ffffff7ff 7ff8000000000000 -c1effc1fffffffff 7ffc000000000000 7ff8000000000000 -c0d000000001ffbf c03ba46e644e4e9c 411ba46e6451c2ba -c4500000005fffff c03a20ab4de47fc9 449a20ab4e8143cc -400e00000000007e 001fffffffffffff 003e00000000007e -45a01fffff7fffff c3c0020200000000 c9702206037fefee -3e8ff800000000ff 3caffffffffffffe 3b4ff800000000fe -be004000000007fe 3fdffff7ff7fffff bdf03ffbefbf07fd -b11000007ffffe00 3fe0000000000000 b10000007ffffe00 -b80cef50bd17db40 c05fffc00000000e 387cef16de76611d -3d4000ffffffffff 3d47f68d8eb6b9a4 3a97f80cf78fa50f -ffe3fffffffffffb c03dc3321aaa5380 003299ff50aa742c -3ca3fffffffffeff bf02ffafb4e9241d bbb7bf9ba2236bf3 -53598c812c3c39dd 3f20000100fffffe 52898c82c69d14b1 -c3dffffff8000001 3fe0020000003ffe c3d001fffbffbffe -7ba00800003fffff 3ff9a9a129c791b3 7ba9b675fac31bff -c3d0000fffffffef 7fe0000000000001 83c0000ffffffff0 -c34f80001fffffff b7fffffe0007ffff 3b5f7ffe2807ddff -0010000000001ff8 4800020000010000 0820020000011ffc -2c4c0000003fffff 230ffffc00400000 0f6bfffc8077fff8 -381fffffffbff7fe 8010000000000000 f83fffffffbff7fe -802d3018ea8c241d c007fdffffffffff 0045e23fae5a7253 -43e047fffffffffe 4000003ffdfffffe 43f048411df6fffc -c000005fffffffff 403ffffffff00002 c050005ffff7ffd0 -3fc8b60e46a80f6d bfdffffffffffffe bfb8b60e46a80f6b -bd5fdffdffffffff 5644b72ace1bbb6b d3b4a27257daf2cd -b80010001fffffff 40e01ffffff7fffe b8f030202037f7fc -407000003ffbfffe 38042862fe8e3368 388428634f2ab547 -bf8ffbfff7ffffff c00fffffffffffff 3faffbfff7ffffff -bcafc000003fffff c010000000000001 3ccfc00000400001 -47eddf042473ef08 b7e00000fe000000 bfdddf05fea850ca -3fbfffff7fffffef c340ffffffffffbf c310ffffbbffffb5 -c02f8000000007ff ffe0000000000001 001f800000000801 -002f37ebf6c8eaec c08be464f4c81c69 80cb36000706e168 -c00e800000000000 7ffc000000000000 7ff8000000000000 -0010000000000000 0000000000000000 0000000000000000 -bfffc00000000003 391001ffffffffff b91fc3f800000001 -c1db54446247aa52 bfcc001fffffffff 41b7e9d72a43174f -0010000000000000 c0392c59c8e48f37 80592c59c8e48f37 -0010000000000000 c0000800000001ff 80200800000001ff -0010000000000000 c1d0000004000fff 81f0000004000fff -4030040000200000 0017055f48beeff5 00570b20a0bf2a70 -bc7000000000ffee c1e0001100000000 3e6000110000fff0 -c040000000007fff c3b2a6c91c557f56 4402a6c91c56148c -41ffffffff003fff c3b0000007ffffee c5c0000007801fed -21900001dfffffff bf20000017fffffe a0c00001f80002cc -0029954d0f0df5b3 41e00000000003ff 0219954d0f0dfc17 -b810000020000001 47ffdfffffffff80 c01fe0003fbfff81 -0010000000000000 ffeffff800007fff c00ffff800007fff -0010000000000000 4010000000000000 0030000000000000 -bf700000000100ff 401fffffffffffff bfa00000000100fe -37feffffffffffff 47ef8000000fffff 3ffe8400000f7fff -b80f800001fffffe 44e00000ffff7fff bcff8001f9ff041c -0010000000000000 434ffffffffffffe 036ffffffffffffe -41ffffdfffff8000 7fe0000000000001 01efffdfffff8002 -b80a16ad02c87cd3 380fffffffffe7fe b02a16ad02c86940 -47f0fffffffffffb 7ffc000000000000 7ff8000000000000 -0010000000000000 41ffffffffbfff7f 021fffffffbfff7f -0010000000000000 8000000000000000 0000000000000000 -c3d00001000001ff b7f60cb3edb38762 3bd60cb54e7ec8fe -0010000000000000 8010000000000001 c030000000000001 -43c0007fffdfffff 801ffffffffffffe 83f0007fffdffffd -c7efffffdffffbff bca0000000000001 449fffffdffffc01 -0010000000000000 c11ff00000000003 813ff00000000003 -0010000000000000 bfd0000000000000 ffefffffffffffff -c0ffffffffeffffe bfdfffffffffffff 40efffffffeffffe -6f7000000001fdff 1510010000000fff 4490010000020e1e -37f002000000000f b1effcfffffffffe a9f0007fd000000d -cc3050bc013d7cd7 bff0000000000000 4c3050bc013d7cd7 -0010000000000000 87fff0000000fffe c81ff0000000fffe -0010000000000000 bffffffffffffffe 801ffffffffffffe -43effbfffffff7ff 7fefffffff801ffe 03effbffff8027fa -c015834380f2b995 3f9fff0000000400 bfc5829766d6b4af -0010000000000000 41dfffffc0001000 01ffffffc0001000 -0010000000000000 c01fffffffffffff 803fffffffffffff -41e010000000001f c5b04000000fffff c7a050400010101e -3b40018000000000 3ea0400000000100 39f0418600000101 -0010000000000000 4cdffeffff7fffff 0cfffeffff7fffff -16dff0001ffffffe 3fb500ae0796659d 16a4f62dc5934871 -b7e003ffffffff7f deafffffeffffffd 56a003fff7fdff7e -406000001fffbfff 3f20020000080000 3f900200200bbff8 -0010000000000000 7ffc000000000000 7ff8000000000000 -439fbffffffbffff bf8454fd38ef0ba0 c3342c533e7aa2e8 -c1c000000200007e bf000001ffffffbf 40d000020200007e -480000000008fffe 001637e790e69de2 082637e790f31d52 -bffffffc000003fe 3ca0000000000001 bcaffffc000003ff -6b4848a9a8c0dcd5 480ffffffffbdfff 736848a9a8bdbb77 diff --git a/wally-pipelined/src/fpu/FMA/tbgen/output b/wally-pipelined/src/fpu/FMA/tbgen/output deleted file mode 100644 index 89af6079..00000000 --- a/wally-pipelined/src/fpu/FMA/tbgen/output +++ /dev/null @@ -1,199 +0,0 @@ -c22000007fffffff 24700000ffffffef a6a00001800007ee -bfc00000000011fe 3fdfffffffffff03 bfb000000000117f -a83100000007fffe 41e0000effffffff aa21000ff0080004 -0000000000000000 001ffffffffffffe 0000000000000000 -400327ca64d70ec7 3ca0000000000001 3cb327ca64d70ec8 -0000000000000000 43e207ffffffffff 0000000000000000 -0000000000000000 3fd0000000000000 0000000000000000 -0000000000000000 3fdfffffffffffff 0000000000000000 -0000000000000000 3fe0000000000000 0000000000000000 -c870200000010000 3fefffffffffffff c87020000000ffff -c00aaa4fd557ef13 c3b8917384eb32d0 43d478efdc9216d7 -0000000000000000 7ffc000000000000 7ffc000000000000 -0000000000000000 c18aca47203438e2 8000000000000000 -0000000000000000 4000000000000001 0000000000000000 -47efff0008000000 b1dcb0523546117f b9dcaf6cb9e07bdc -43f000ffffff7fff 22300000001fffdf 26300100001f81de -402ff000001fffff 40759558e27de226 40b58a8e3622388d -0000000000000000 40efdeffffffffff 0000000000000000 -0000000000000000 434fffffffffffff 0000000000000000 -7ffc000000000000 7fe0000000000000 7ffc000000000000 -b35e061abc769f3a c078000003fffffe 33e684941119bac1 -403a793cfb1e2471 bff0000100007fff c03a793ea2b2c7eb -3d1ffffbfe000000 216898822a24af3f 1e98987f158ae1d8 -bfb00000001bffff 7ffc000000000000 7ffc000000000000 -37f0000000efffff c3d00007fffffeff bbd0000800efff76 -0000000000000000 ffefff8000080000 8000000000000000 -3fb00200000000ff c0000000011fffff bfc00200012024fe -41c0000007ffffff 49103fffefffffff 4ae03ffff81ffff6 -407effbfffffffff 3e00000040001fff 3e8effc07bff3dfd -c1f00013fffffffe 7ffc000000000000 7ffc000000000000 -c3f00004000001ff c3d00bfffffffffe 47d00c04030001fe -403b5ab30b28be12 bfdfffffffffffff c02b5ab30b28be11 -0000000000000000 c1cfffffff87ffff 8000000000000000 -0000000000000000 bfe0000000000001 8000000000000000 -801ffc000007ffff bfeffffffffffffe 001ffc000007fffd -0000000000000000 ffe0000005fffffe 8000000000000000 -0000000000000000 bfffffffffffffff 8000000000000000 -0000000000000000 c000000000000000 8000000000000000 -c3d09308769f3f51 c00fffffffffffff 43f09308769f3f50 -0000000000000000 402ffffdfefffffe 0000000000000000 -0000000000000000 c010000000000001 8000000000000000 -c01fffffffc00fff c01ffffffffffffe 404fffffffc00ffd -c025e14360f49046 412fff0000000003 c165e09456d988a4 -0000000000000000 43ee59a2f1155c8b 0000000000000000 -3fe0000000008fff 802ffffff7fffff6 801ffffff8011ff4 -0000000000000000 ffefffffffffffff 8000000000000000 -40401007fffffffe fff0000000000000 fff0000000000000 -0000000000000000 c0045abb4860cbf3 8000000000000000 -0000000000000000 7ffc000000000000 7ffc000000000000 -bffffffec0000000 c000000000003eff 400ffffec0007dfe -48000000004001ff 41f331de979ac49e 4a0331de97e78e7d -3d0fffffbff7ffff 7ffc000000000000 7ffc000000000000 -43d3ffffff000000 3caffffffffffffe 4093fffffeffffff -7ffc000000000000 43dfff8004000000 7ffc000000000000 -bcaffe0000000008 3fd00008000000ff bc8ffe0fff000206 -404ffbfffffffffc c34ffff8003fffff c3affbf8013ff7fb -43e0000000000082 3db000003ffffeff 41a000003fffff81 -c1d004000ffffffe 4000000000000000 c1e004000ffffffe -c00fffffc000007e c02ffffdfffffbff 404ffffdc000007d -409dfffbffffffff 4010000000000001 40bdfffc00000001 -c120000003ffffe0 c06000fffbffffff 4190010000003fde -3fd1f7ffffffffff c01000001dffffff bff1f80021b0fffe -2e0fefdfffffffff 4030000020000040 2e4fefe03fdfc07f -43c0000803ffffff 3fcfffffffffffff 43a0000803fffffe -c0afffffbffffdfe 3fc07ffdffffffff c0807ffddf0002f6 -c0fffffffeffffee 55139bb9349e058c d6239bb9340127b7 -41ffdbaf18ce06bd 8010000000000000 821fdbaf18ce06bd -c0e1000000080000 801ffffffffffffe 011100000007ffff -3fbffffff0000007 c807dfffffffffff c7d7dffff4100004 -c357b53537b96da5 bfd0000000000000 4337b53537b96da5 -401fffffffffffff ffebff8000000000 fff0000000000000 -c7eff77bf2b59c3c bfe0000000000001 47dff77bf2b59c3e -380c3f72cc3dec98 c3fffffffbffffff bc1c3f72c8b5fe3e -b8e0000003fbffff c503f4d44f4bf888 3df3f4d454443065 -3f3ffffc001fffff c000000000000001 bf4ffffc00200001 -c340002000004000 c0db3367e0423019 442b339e47125d6b -4f60000801ffffff 41c07fe000000000 51307fe841fffbff -c1ffffffbfefffff c340000000000001 454fffffbff00001 -404fff7fffffff7f 48ab7e2aad4ec686 490b7dbcb4a410dc -7ffc000000000000 ffefffffffffffff 7ffc000000000000 -41e189ea1a6fff97 7ffc000000000000 7ffc000000000000 -3ff0ee9046c9330f 8479e1e79766e02b 847b63d14ff91acb -d2f805130a8c11df 43effffdfdfffffe d6f8051188ba9004 -4f1fffbfffe00000 bcd02000000007ff cc001fdfbfefe7ff -be70000077ffffff c1efffffffffffff 4070000077fffffe -41e1ffffbffffffe 3caffffffffffffe 3ea1ffffbffffffd -3bbd976272fb1d2a c06ffff80007fffe bc3d975b0d29e642 -434fff01ffffffff 403dfeffffffffff 439dfe11e7effffe -be6fff7fffffffff 3feffffffffffffe be6fff7ffffffffd -41d007ff80000000 41f0fffffffc0000 43d1087f77fbfe00 -ffeef7a206029708 bdcfa4109a3a5b22 7dce9eaa2542875b -3b6ffffffeffffc0 3c7ffffe003ffffe 37fffffdff3fffce -c1d1ffffffbfffff bfcffffefffff800 41b1ffff6fbffb81 -2030000000000090 c05e2e90015c47a1 a09e2e90015c48b1 -bbf000000007efff 001fe0000007fffe 8000000000000000 -41cae866712069f4 c02fffffffffffff c20ae866712069f3 -bfce1e32ccf56348 3ca1f66d4c8eeef3 bc80e7fa025544db -ffedfffff0000000 ffeffff000000800 7ff0000000000000 -37effffc3ffffffe bca0fffffffffffd b4a0fffe01fffffc -bc950a021bf9dee1 3db0001fffdffffe ba550a2c2fd402ce -fd4fffffdfffffef 41cffffdffffffef ff2ffffde00001de -bfc00000004007ff bcafffffffffffff 3c800000004007fe -c009130b80fe8274 b811571307061a38 382b2cb1993b60f2 -c0600000ffffffdf 7feda1b8c591f9c6 fff0000000000000 -c1e4af3f8d45e031 3ca0020002000000 be94b1d577cd70df -3800008100000000 b810000020000080 b020008120010280 -372ff00000003fff 7fe000fdfffffffe 771ff1fb02003fff -47d00021fffffffe c00fffffffffffff c7f00021fffffffd -bfbc9ea0c2b4884b 43f4a552574073d5 c3c277000b21a4e8 -bf1fe0000000ffff c01ffffffffffffe 3f4fe0000000fffd -41ffffffff7ffffb 0027ffffffffeffe 0237ffffff9feffa -c7e040000fffffff ffe0000000000000 7ff0000000000000 -7ffc000000000000 3fe0000ffffff7ff 7ffc000000000000 -c1effc1fffffffff 7ffc000000000000 7ffc000000000000 -c0d000000001ffbf c03ba46e644e4e9c 411ba46e6451c2ba -c4500000005fffff c03a20ab4de47fc9 449a20ab4e8143cb -400e00000000007e 001fffffffffffff 003e00000000007d -45a01fffff7fffff c3c0020200000000 c9702206037fefef -3e8ff800000000ff 3caffffffffffffe 3b4ff800000000fd -be004000000007fe 3fdffff7ff7fffff bdf03ffbefbf07fd -b11000007ffffe00 3fe0000000000000 b10000007ffffe00 -b80cef50bd17db40 c05fffc00000000e 387cef16de76611d -3d4000ffffffffff 3d47f68d8eb6b9a4 3a97f80cf78fa50e -ffe3fffffffffffb c03dc3321aaa5380 7ff0000000000000 -3ca3fffffffffeff bf02ffafb4e9241d bbb7bf9ba2236bf3 -53598c812c3c39dd 3f20000100fffffe 52898c82c69d14b0 -c3dffffff8000001 3fe0020000003ffe c3d001fffbffbfff -7ba00800003fffff 3ff9a9a129c791b3 7ba9b675fac31bff -c3d0000fffffffef 7fe0000000000001 fff0000000000000 -c34f80001fffffff b7fffffe0007ffff 3b5f7ffe2807ddfe -0010000000001ff8 4800020000010000 0820020000011ffc -2c4c0000003fffff 230ffffc00400000 0f6bfffc8077fff7 -381fffffffbff7fe 8010000000000000 8000000000000000 -802d3018ea8c241d c007fdffffffffff 0045e23fae5a7253 -43e047fffffffffe 4000003ffdfffffe 43f048411df6fffc -c000005fffffffff 403ffffffff00002 c050005ffff7ffd0 -3fc8b60e46a80f6d bfdffffffffffffe bfb8b60e46a80f6b -bd5fdffdffffffff 5644b72ace1bbb6b d3b4a27257daf2cd -b80010001fffffff 40e01ffffff7fffe b8f030202037f7fd -407000003ffbfffe 38042862fe8e3368 388428634f2ab547 -bf8ffbfff7ffffff c00fffffffffffff 3faffbfff7fffffe -bcafc000003fffff c010000000000001 3ccfc00000400001 -47eddf042473ef08 b7e00000fe000000 bfdddf05fea850cb -3fbfffff7fffffef c340ffffffffffbf c310ffffbbffffb6 -c02f8000000007ff ffe0000000000001 7ff0000000000000 -002f37ebf6c8eaec c08be464f4c81c69 80cb36000706e169 -c00e800000000000 7ffc000000000000 7ffc000000000000 -0010000000000000 0000000000000000 0000000000000000 -bfffc00000000003 391001ffffffffff b91fc3f800000001 -c1db54446247aa52 bfcc001fffffffff 41b7e9d72a43174f -0010000000000000 c0392c59c8e48f37 80592c59c8e48f37 -0010000000000000 c0000800000001ff 80200800000001ff -0010000000000000 c1d0000004000fff 81f0000004000fff -4030040000200000 0017055f48beeff5 00570b20a0bf2a70 -bc7000000000ffee c1e0001100000000 3e6000110000ffef -c040000000007fff c3b2a6c91c557f56 4402a6c91c56148b -41ffffffff003fff c3b0000007ffffee c5c0000007801fed -21900001dfffffff bf20000017fffffe a0c00001f80002cd -0029954d0f0df5b3 41e00000000003ff 0219954d0f0dfc17 -b810000020000001 47ffdfffffffff80 c01fe0003fbfff82 -0010000000000000 ffeffff800007fff c00ffff800007fff -0010000000000000 4010000000000000 0030000000000000 -bf700000000100ff 401fffffffffffff bfa00000000100fe -37feffffffffffff 47ef8000000fffff 3ffe8400000f7ffe -b80f800001fffffe 44e00000ffff7fff bcff8001f9ff041c -0010000000000000 434ffffffffffffe 036ffffffffffffe -41ffffdfffff8000 7fe0000000000001 7ff0000000000000 -b80a16ad02c87cd3 380fffffffffe7fe b02a16ad02c86940 -47f0fffffffffffb 7ffc000000000000 7ffc000000000000 -0010000000000000 41ffffffffbfff7f 021fffffffbfff7f -0010000000000000 8000000000000000 8000000000000000 -c3d00001000001ff b7f60cb3edb38762 3bd60cb54e7ec8fd -0010000000000000 8010000000000001 8000000000000000 -43c0007fffdfffff 801ffffffffffffe 83f0007fffdffffe -c7efffffdffffbff bca0000000000001 449fffffdffffc01 -0010000000000000 c11ff00000000003 813ff00000000003 -0010000000000000 bfd0000000000000 8000000000000000 -c0ffffffffeffffe bfdfffffffffffff 40efffffffeffffd -6f7000000001fdff 1510010000000fff 4490010000020e1e -37f002000000000f b1effcfffffffffe a9f0007fd000000e -cc3050bc013d7cd7 bff0000000000000 4c3050bc013d7cd7 -0010000000000000 87fff0000000fffe 8000000000000000 -0010000000000000 bffffffffffffffe 801ffffffffffffe -43effbfffffff7ff 7fefffffff801ffe 7ff0000000000000 -c015834380f2b995 3f9fff0000000400 bfc5829766d6b4b0 -0010000000000000 41dfffffc0001000 01ffffffc0001000 -0010000000000000 c01fffffffffffff 803fffffffffffff -41e010000000001f c5b04000000fffff c7a050400010101e -3b40018000000000 3ea0400000000100 39f0418600000100 -0010000000000000 4cdffeffff7fffff 0cfffeffff7fffff -16dff0001ffffffe 3fb500ae0796659d 16a4f62dc5934870 -b7e003ffffffff7f deafffffeffffffd 56a003fff7fdff7d -406000001fffbfff 3f20020000080000 3f900200200bbff7 -0010000000000000 7ffc000000000000 7ffc000000000000 -439fbffffffbffff bf8454fd38ef0ba0 c3342c533e7aa2e8 -c1c000000200007e bf000001ffffffbf 40d000020200007d -480000000008fffe 001637e790e69de2 082637e790f31d51 -bffffffc000003fe 3ca0000000000001 bcaffffc00000400 -6b4848a9a8c0dcd5 480ffffffffbdfff 736848a9a8bdbb76 diff --git a/wally-pipelined/src/fpu/FMA/tbgen/results.srt b/wally-pipelined/src/fpu/FMA/tbgen/results.srt new file mode 100644 index 00000000..eda76cb2 --- /dev/null +++ b/wally-pipelined/src/fpu/FMA/tbgen/results.srt @@ -0,0 +1,111 @@ +3fdfffffffffffff 7fefffffffffffff ffe0000000000001 fcafffffffffffff fcb0000000000000 Wrong 1008219 +3fdfffffffffffff bcafffffffffffff 3fde6565aa50f6d7 bf99a9a55af092b0 3fde6565aa50f6d5 Wrong 1020499 +c1b000000007fffc f792000000000000 bfeffffffffffffe 795200000008fffc 795200000008fffb Wrong 1169087 +3fefffffffffffff 4010000000000001 43600000080007ff 43600000080007ff 4360000008000800 Wrong 1280221 +3fefffffffffffff bca00000001ffff7 bffb69bd490d5d32 bffb69bd490d5d32 bffb69bd490d5d33 Wrong 1309693 +3feffffffffffffe bca0000000000001 3fe00000ffffffbf bfdffffe00000084 3fe00000ffffffbe Wrong 1368637 +3ff0000000000000 3fffdffffffffffe c34ffffffbfffdff 41a0000807fc0000 c34ffffffbfffdfe Wrong 1414687 +3ff0000000000000 bcafffffffffffff 3ffffffffffffffe bcc8000000000000 3ffffffffffffffd Wrong 1439247 +3ff0000000000001 c340000000000001 bfeffffffffffffe c340000000000002 c340000000000003 Wrong 1527663 +47afffffbffc0000 3847cedaf8426a4c c34ffffff800007f 41affffe09f3b6b2 c34ffffff800007e Wrong 1667655 +4000000000000000 3fdffffffffffffe bff0000000000000 bcaffffffffffffe bcb0000000000000 Wrong 1687917 +400fffffffffffff 3fd0000000000001 c340000000000001 c340000000000001 c340000000000000 Wrong 1826067 +4010000000000000 bca00ffffffffffe 401fc0000fffffff bfaffff8000000c0 401fc0000ffffffe Wrong 1972813 +3fdfffffffffffdb 3cafffffffffffff bfeffffffffffffe bfeffffffffffffe bfeffffffffffffd Wrong 2032985 +4010000000000001 bfd0000000000000 4340000000000001 c33fffffffffffff 4340000000000000 Wrong 2069211 +bfffffffffffffde bfe0040000003ffe c34fffffffffffff c34fffffffffffff c34ffffffffffffe Wrong 2114033 +bfe886c7cff8293d c00ff000000000fe 434fffffffffffff 3ff0f508d8205bd6 4350000000000000 Wrong 2843465 +c02ffffffffffffe 404fffc007fffffe 43cfeffffffdffff c340000002000300 43cfeffffffdfffd Wrong 3439045 +bcafffffffffffff 3fffffffffffffff c000000000000000 c000000000000000 c000000000000001 Wrong 3787797 +bcafffffffffffff bfd0000000000001 bca0000000000001 bc90000000000001 bc90000000000002 Wrong 3815427 +3ca3809288505f2e bfeffffffffffffe 3ffffffffffffffe 3ffffffffffffffe 3ffffffffffffffd Wrong 3889721 +bfd0000000000001 c010000000000001 c3400010003ffffe 433fffdfff800005 c3400010003ffffd Wrong 4037695 +bfdfffffffffffff c01fffffffffffff c00fffffffffffff bcbffffffffffffd bcbfffffffffffff Wrong 4108305 +bfdffffffffffffe c00fffffffffffff 434fffffffffffff 434fffffffffffff 4350000000000000 Wrong 4174617 +bfe0000000000000 3fe0000000000001 3feffffffffffffe 3fe7fffffffffffd 3fe7fffffffffffe Wrong 4202247 +bfe0000000000001 bcafffffffffffff bca0000000000001 b94ffffffffffffe b950000000000001 Wrong 4301715 +bff0000000000001 bff0000000000000 c010000000000001 c008000000000001 c008000000000002 Wrong 4589067 +bafff9ffffffffff c18fffffffffffff bfe44b07ce3485bb bfe44b07ce3485bb bfe44b07ce3485ba Wrong 4640643 +bfffffffffffffff bffffffffffffffe 434fffffffffffff 3ffffffffffffffa 4350000000000000 Wrong 4660905 +bffffffffffffffe 3fdfffffffffffff 3feffffffffffffe 3c9ffffffffffffc 3c9ffffffffffffe Wrong 4688535 +3ff6119af86b7717 bfeffffffffffffe 4340000000000000 4340000000000000 433fffffffffffff Wrong 469127 +c000000000000001 3fd0000000000000 4340000000000000 4340000000000000 433fffffffffffff Wrong 4826685 +be02001ffffffffe bfdf000400000000 c13e2351e06b232f 40fdcae1f94dcd21 c13e2351e06b232e Wrong 5082723 +c010000000000001 bca0000000000000 c0100007f7fffffe 400ffff010000005 c0100007f7fffffd Wrong 5137369 +ffe0000000000000 bcaffffffffffffe ffee000000008000 7faffffffff80010 ffee000000007fff Wrong 5629183 +3a0c00000000007f 400ffffffffffffe 3d70200003fffffe 3d70200003fffffe 3d70200003ffffff Wrong 5885835 +3ca0000000000000 c010000000000000 401fffffffffffff bcd8000000000000 401ffffffffffffe Wrong 615873 +3cafffffffffffff 401fffffffffffff 4021e792682c4909 4021e792682c4909 4021e792682c490a Wrong 722095 +3caffffffffffffe c01bf4d171e6823d c01fffffffffffff bcc7e9a2e3cd0477 c020000000000000 Wrong 769373 +3fd0000000000000 c00fffe7ffffffff 4340000000000000 4340000000000000 433fffffffffffff Wrong 846737 +3fd0000000000000 c01ffffffffffffe bca0000000000001 bffffffffffffffe bfffffffffffffff Wrong 897699 +3fd0000000000001 bff0000000000000 3ff0000000000000 3fe7ffffffffffff 3fe8000000000000 Wrong 958485 +801fffffffffffff bfbffffffffd7ffe 0000000000000000 0000000000000000 0003ffffffffb000 Wrong unflw 3499217 +0010000000000001 bd0081ffffffffff 0010000000000001 0000000000000000 000fffffffffffe0 Wrong unflw 410183 +0021ffffffffff7e 3feffffffffffffe 801fff0010000000 0000000000000000 000400ffeffffefa Wrong unflw 4134093 +001fffffffffffff 3caffffffffffffe 8000000000000000 0000000000000000 0000000000000002 Wrong unflw 427989 +80220000000000ff bcaffffffffffffe 802ffffff00fffff 0000000000000000 802ffffff00ffffe Wrong unflw 5349813 +82c0040000007fff 3ca0000000000000 0010000000000001 0000000000000000 000ffbfeffffffe1 Wrong unflw 5381741 +3fe0000000000000 801ffffffffffffe 0000000000000000 8000000000000000 800fffffffffffff Wrong w=-zero unflw 1157421 +0010000000000000 c000000000000001 001ffffffffffffe 8000000000000000 8000000000000004 Wrong w=-zero unflw 334047 +801fffffffffffff bfe0000040000000 801fffffdffffffd 8000000000000000 800fffff9ffffffe Wrong w=-zero unflw 3525619 +001fffffffffffff 3fe100000fffffff 801ffffffffffffe 8000000000000000 800efffff0000000 Wrong w=-zero unflw 487547 +000fffffffffffff bfd0000000000001 0000000000000000 8000000000000000 8004000000000000 Wrong w=-zero xdenorm unflw 184845 +800ffffffffffffe bffffffffffffffe 801fffffffffffff 8000000000000000 8000000000000005 Wrong w=-zero xdenorm unflw 3334665 +0000000000000001 c340000000000000 0021f7ffffffffff 8350000000000000 0003effffffffffe Wrong xdenorm 130813 +0000000000000001 ffefffffffffffff 400ffffffffffffe 3ffffffffffffff9 400ffffffffffffc Wrong xdenorm 135111 +0000000000000001 ffeffffffffffffe 38041fffffffffff c000000000000001 bccffffffffffffe Wrong xdenorm 136339 +000fffffffffffff 7fe0000000000000 3ca0000000000001 3ffffffffffffffe 3fffffffffffffff Wrong xdenorm 168267 +000f7ffffffffbfe 7fdfffffffeeffff c34fffffffffffff c34fffffffffffff c34ffffffffffffe Wrong xdenorm 168881 +00076127f4ebe458 7feffffff7f7fffe c1d0def838064556 c1d0def8371032d7 c1d0def8379032d7 Wrong xdenorm 2761803 +8000000000000001 bfcf000000003ffe 0010000000000000 0011f00000000400 0010000000000000 Wrong xdenorm 3167657 +8000000000000001 ffeffffffffffffe 401ffffffffffffe 4023ffffffffffff 401fffffffffffff Wrong xdenorm 3207567 +000000000008ffff 7feffffffffffffe 4340000000000000 4340000000000001 4340000000000000 Wrong xdenorm 4359431 +8006734cfd26d7ab bfeffffffffffffe 001ffffffffffffe 002739a67e936bd4 002339a67e936bd4 Wrong xdenorm 5215961 +00056efa865ceb48 ffdf7fdfffffffff c000000000000000 c00d39312d48f13e c00559392d48f13e Wrong xdenorm 5860661 +0000000000000001 3fcce6810165a323 001fffffffffffff 0020e734080b2d19 001fffffffffffff Wrong xdenorm 84149 +0000000000000001 48001caa6570456b 0000000000000000 08101caa6570456d 04e01caa6570456b Wrong xdenorm 95201 +0000000000000001 4340000000000001 8010000000000000 0350000000000002 0010000000000002 Wrong xdenorm 96429 +000ffffffffffffe bfeb2c0fbae7607b 0010000000000000 0000000000000000 000269f8228c4fc4 Wrong xdenorm unflw 249929 +0000000000000001 400fffffffffffff 801ffffffffffffe 0000000000000000 801ffffffffffffa Wrong xdenorm unflw 90903 +8000000000000001 c03ffffffffffef7 0000000000000001 00507fffffffff7e 0000000000000021 Wrong xdenorm zdenorm 3173183 +800fffffffffffff 3f1dffffffffbfff 800ffffffffffffe 80100077fffffffe 80100077fffffffd Wrong xdenorm zdenorm 3250547 +800fffffffffffff bff0000000000001 0000000000000001 0018000000000000 0010000000000001 Wrong xdenorm zdenorm 3262827 +800ffffffffffffe c01fffffffffffff 800ffffffffffffe 003bfffffffffffb 003bfffffffffffc Wrong xdenorm zdenorm 3340191 +8001c94a70185f15 bf9080000000001e 0000000000000001 000050bca61cc912 0000075e530e6489 Wrong xdenorm zdenorm 5335691 +0000000000000001 c3c000004000001f 000ffffffffffffe 83d0000040000021 809ff0008000003e Wrong xdenorm zdenorm 89675 +4010000000000000 800002fffffffffe 8019e21990370ecf 802cf70cc81b8764 8019ee1990370ec7 Wrong ydenorm 2011495 +ffd00000000013fe 8000000000000001 8010000000000000 3fe0000000001400 3cb00000000013fe Wrong ydenorm 2060615 +401fffffffffffff 8000000000000001 0000000000000000 8030000000000001 8000000000000008 Wrong ydenorm 2129997 +401ffffffffffffe 8000000fc0000000 0010000000000000 8028003efffffffe 000fff8200000000 Wrong ydenorm 2195081 +7fe0000000000000 000000000000007f 40108001ffffffff 401480020000003e 401080020000003e Wrong ydenorm 2558569 +7fe0000000000001 0000000000000001 b80ffeffffffff7f 3ff0000000000003 3cc0000000000001 Wrong ydenorm 2584357 +7fe0000000000001 80058a95d520aff2 bcaffffffffffffe bffb152baa415fe7 bfe62a575482bfcb Wrong ydenorm 2587427 +bfe0000000000000 8000000000000001 001ffffffffffffe 0021ffffffffffff 001ffffffffffffe Wrong ydenorm 4224351 +c1dfffffffffd7ff 00008000003fffff 001ffffffffffffe 81f0ffffffffeabd 81afffffffffd7bf Wrong ydenorm 461759 +ffe0000000000001 0000000000000001 3fffffffffffffff 3feffffffffffff8 3ffffffffffffffd Wrong ydenorm 5655585 +ffe0000000000001 8005e2e035872cbc 4010000000000001 4016f1701ac3965f 4012f1701ac3965f Wrong ydenorm 5715143 +ffefffffffffffff 8000000000000001 bca0000000000001 4000000000000001 3ccbffffffffffff Wrong ydenorm 5760579 +41ffffffffffff87 8000000000000001 0000000000000000 820fffffffffff8b 8000000200000000 Wrong ydenorm 6039335 +3fe0000000000001 8000008100000000 0010000000000000 0000000000000000 000fffbf80000000 Wrong ydenorm unflw 1222505 +400ffffffffffffe 8000000000000001 0000000001ffff80 8017ffffff000042 0000000001ffff7c Wrong ydenorm zdenorm 1921237 +40afae6465ddbca7 00006f1e30d0e43a 800ffffffffffffe 00c0b137d3169bd3 007b40b404f7afe8 Wrong ydenorm zdenorm 2495327 +c05d0d58b7637bf5 000ffffffffffffe 8002f77910ff1aeb 807d3347a9857a27 807d19369ba7785d Wrong ydenorm zdenorm 2724963 +3fc8b2426b25d8d2 80000200007fffff 000fffffffffffff 000ce8f220568732 000fff9d36dda125 Wrong ydenorm zdenorm 3064505 +bca0000000000000 8000000000000001 800fffffffffffff 7cc8000000000001 800fffffffffffff Wrong ydenorm zdenorm 3666225 +c3e760ff13e9db70 0000000000000001 800ffffffffffffe 83f760ff13e9db73 80c762ff13e9db70 Wrong ydenorm zdenorm 4818089 +e9b000000040000e 8000000000000001 000fffffffffffff 29c0000000400010 269000000040000e Wrong ydenorm zdenorm 524387 +3ca0000000000001 800ffffffffffffe 000ffffffffffffe fcd7ffffffffffff 000ffffffffffffe Wrong ydenorm zdenorm 665607 +3fd0000000000001 0000000000000001 800ffffffffffffe 800bfffffffffffd 800ffffffffffffe Wrong ydenorm zdenorm 908751 +3fe0000000000000 802ffffffbfffffc 000ffff7ffffffbf 80100003fc00001c 80100007fc00003d Wrong zdenorm 1154965 +3feffffffffffffe 801ffffffffffffb 000fffffffffffff 800ffffffffffff3 800ffffffffffffa Wrong zdenorm 1388285 +3ffffffffffffffe 002bffbffffffffe 000ff7fffffffefe 003ffebfffffffdc 003ffdbfffffffbc Wrong zdenorm 1663357 +bff0000040040000 001ffffffffffffe 0000000000000001 801800008007fffd 802000004003fffe Wrong zdenorm 2309285 +001ffffbfffff7ff bffafaef051722b5 000ffffffffffffe 8022faeba5b93b53 8022faeba5b93b54 Wrong zdenorm 3224759 +8010000000000000 3ff00000000000c0 8000000000000001 80180000000000c0 80100000000000c1 Wrong zdenorm 3416327 +801fffffffffffff 3feffffffffffffe 8000000000000001 8023ffffffffffff 801ffffffffffffe Wrong zdenorm 3505971 +0010000000000001 bfbfffffc07fffff 000fffffffffffff 000c000007efffff 000e000003f7ffff Wrong zdenorm 415709 +001ffffffffffffe 3ff0000000000001 000fffffffffffff 0028000000000000 0027ffffffffffff Wrong zdenorm 505353 +001ffffffffffffe 4010000000000001 0000003ffbffffff 00410003ffc00000 00400007ff800000 Wrong zdenorm 512107 +0020007fffffffff bcafffffffffffff 800fffffffffffff 8010000000000002 8010000000000001 Wrong zdenorm 6116699 +3ca0000000000001 00184112bdfd66a0 800fffffffffffff 800ffffffffffffd 800ffffffffffffe Wrong zdenorm 658853 diff --git a/wally-pipelined/src/fpu/FMA/tbgen/tb b/wally-pipelined/src/fpu/FMA/tbgen/tb index 3245134a2e26ebeeee7b352fd9c1d18f234fcca3..996bd4d4b18c4e457f6e84e6df3e40a337c95a51 100755 GIT binary patch delta 1092 zcmZvcT}V@59LD!czuJN}vfPDzC=M+V%nMm0B_uS>GD!;2 zO8paf6BHzUKt%0E40M6vjL0s!P*kv3u*yt=%%yaC-?`=)crMQSywC6XKj%GgIH9Ic zQ~&$KLX#|V6%Ndf8(6%#VX-43Sa^))xG>Y*a(8AT_^@W6qgCG5eQRN3-8Uo;CMagF z)kCMcPCl=KdG#0jXPral>X{s&v!OQ|qUgGLr$Ho3@8OxTRVjSB30M9`p=yx92!n~i zX?yjOl2bHCrblVzSTR(RSQ#`knWzeG6MY7rFj(11MnZ?+8N;JNSS0o^tdpjf)c(1? z+2HDVHR`4%h}_2gVAWuh0u>sp^cqO)K2&OWPiTesDYlI6Zvej>e<*2y*dy zUo{`xkx{lJiXG%-xbLD^K~}UZiVx`imncqCoKNo0iFU&*-i=%k#^tER z=QK^rp}{2h^y#$;h=r~!USW_qd|g?;5wiH&_8ezWGfd^@CvN=-{X|7U(-c?;`lCS6eD4mUd_#+6uyY~YE3BAYW#@D6r*RwO7Uq6`y3)7xlV&%g<_Wxt;x%^`{Ykf6IJHCW+DC!M$ONRw`++3-f< zb^M~w6x`6@V#i)0xU{RFo1$6?N}N9mGa8)Y$RL8u4JgyH3YyAk%AhIWv=}+StHq}7 zeWd?-o$g<^7XR&5;hfeglVRx7*2q*Cmb7`u3M$8E;}nJOT7G zIWWo`--)Q5j?D=lWS90>vcC#KC;0|35-Uku{w4@dX&n=U2@+eN1l!SLXu<_#9VEFM z-rxh|v(MuSR28 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"613\n"); + $fwrite(fp,"2013\n"); end - xrf = 64'h0000000000000000; - y = 64'h0000000000000001; - zrf = 64'hC1C88840B841DACF; - ans = 64'hC1C88840B841DACF; + x = 64'h37F0000000014000; + y = 64'h37FFDFFFFFFFFF7F; + z = 64'h802FBFFFFFFFFEFF; + ans = 64'h2FFFE00000027CFF; rn = 1; rz = 0; rm = 0; @@ -105,19 +103,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -133,4523 +131,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1227\n"); + $fwrite(fp,"4027\n"); end - xrf = 64'h88800000803FFFFF; - y = 64'hC3D000001FFFDFFF; - zrf = 64'hBFB539DBC8083233; - ans = 64'hBFB539DBC8083233; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1841\n"); - end - xrf = 64'h27F0000008000004; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h3CA0000000000000; - ans = 64'h3CA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2455\n"); - end - xrf = 64'h0000000000000000; - y = 64'hBFABA4A2A8700F1E; - zrf = 64'hBC0FFFFF7FFFFFFD; - ans = 64'hBC0FFFFF7FFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3069\n"); - end - xrf = 64'hC1FFFFFFFFFF77FF; - y = 64'h0010000000000000; - zrf = 64'hC51B6366DC541E43; - ans = 64'hC51B6366DC541E43; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3683\n"); - end - xrf = 64'h0000000000000000; - y = 64'hC3DFE00040000000; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4297\n"); - end - xrf = 64'hBF6FFFFFFFF7F7FE; - y = 64'hC1C000000017FFFE; - zrf = 64'h3FBFFFFFFFFFFF7F; - ans = 64'h414000001013FBFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4911\n"); - end - xrf = 64'h0000000000000000; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5525\n"); - end - xrf = 64'hB03C000000000006; - y = 64'h3810000020000003; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6139\n"); - end - xrf = 64'h0000000000000000; - y = 64'h3CA0000000000000; - zrf = 64'hBFC514F1AE3BBAA4; - ans = 64'hBFC514F1AE3BBAA4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6753\n"); - end - xrf = 64'h3FCDCBA8116A4E79; - y = 64'hB4EFF00100000000; - zrf = 64'h3F9000000000FDFE; - ans = 64'h3F9000000000FDFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"7367\n"); - end - xrf = 64'hCF10000001000000; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h0010000000000001; - ans = 64'hCBD0000000FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"7981\n"); - end - xrf = 64'h0000000000000000; - y = 64'hBFCFFFFFFFFFEFBF; - zrf = 64'h37FA7539FC60F374; - ans = 64'h37FA7539FC60F374; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"8595\n"); - end - xrf = 64'h41CFFFFFFFFBFE00; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'hFFDFFEFFFFFFBFFF; - ans = 64'hFFDFFEFFFFFFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"9209\n"); - end - xrf = 64'h0000000000000000; - y = 64'hFFEFFFFFFFE03FFE; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"9823\n"); - end - xrf = 64'hC3CFFFFFFFFFFFDB; - y = 64'hC020001EFFFFFFFF; - zrf = 64'h41FFFFE0003FFFFF; - ans = 64'h4400001F000FFFDC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"10437\n"); - end - xrf = 64'h0000000000000000; - y = 64'h3FD0000000000001; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"11051\n"); - end - xrf = 64'h47FFFFFBFFFFFFC0; - y = 64'hBFE0000000600000; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hC7EFFFFC00BFFFA8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"11665\n"); - end - xrf = 64'h0000000000000000; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h3FE000000000100E; - ans = 64'h3FE000000000100E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"12279\n"); - end - xrf = 64'h4070000001F80000; - y = 64'h3FE0000001FE0000; - zrf = 64'hBB81000001000000; - ans = 64'h4060000003F60000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"12893\n"); - end - xrf = 64'h3CA1000000000004; - y = 64'h3FE0000000000001; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h3C91000000000005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"13507\n"); - end - xrf = 64'h0000000000000000; - y = 64'h8011000000000000; - zrf = 64'h41EBFFFFFFF7FFFF; - ans = 64'h41EBFFFFFFF7FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"14121\n"); - end - xrf = 64'h3FEFFFFFFEFFFFFE; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'hC010000040001000; - ans = 64'hC008000080402001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"14735\n"); - end - xrf = 64'h0000000000000000; - y = 64'h43EFFFFFFFFFFDFF; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h401FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"15349\n"); - end - xrf = 64'h3FE9D75B0FC2F002; - y = 64'h3FDFFFFFFFF8003F; - zrf = 64'h4147CAF4689FF67D; - ans = 64'h4147CAF49C4EAC9C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"15963\n"); - end - xrf = 64'h0000000000000000; - y = 64'h3FF0000000000000; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"16577\n"); - end - xrf = 64'h41C0080000100000; - y = 64'hBCA7F7FFFFFFFFFE; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFE000003007F7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"17191\n"); - end - xrf = 64'h0000000000000000; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hC0AFFFBF7FFFFFFE; - ans = 64'hC0AFFFBF7FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"17805\n"); - end - xrf = 64'hBFF6F566DD405310; - y = 64'hC1F254DB3826CB07; - zrf = 64'h407FFFFFFFFFF7F8; - ans = 64'h41FA4DD6C47475B5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"18419\n"); - end - xrf = 64'h47500004000003FE; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"19033\n"); - end - xrf = 64'h0000000000000000; - y = 64'h456FFFFFFFFFFD7F; - zrf = 64'hBFE42BCBB894D499; - ans = 64'hBFE42BCBB894D499; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"19647\n"); - end - xrf = 64'h480E000000000001; - y = 64'h4000000000000001; - zrf = 64'h802FFFC007FFFFFE; - ans = 64'h481E000000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"20261\n"); - end - xrf = 64'h0000000000000000; - y = 64'h4B13504F83E4334E; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"20875\n"); - end - xrf = 64'hB9607DFFFFFFFFFF; - y = 64'h3CADFFFFFFFFFFFE; - zrf = 64'hC39FFFFE00000003; - ans = 64'hC39FFFFE00000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"21489\n"); - end - xrf = 64'h0000000000000000; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"22103\n"); - end - xrf = 64'hC010200000000002; - y = 64'h7FE0080000001FFF; - zrf = 64'hBFD0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"22717\n"); - end - xrf = 64'h0000000000000000; - y = 64'h4010000000000001; - zrf = 64'h450000000001FFFE; - ans = 64'h450000000001FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"23331\n"); - end - xrf = 64'h47EFFFFFFFFFEFFE; - y = 64'hC01000FFFFFFFFFF; - zrf = 64'h3EBA653A07ABC2BC; - ans = 64'hC81000FFFFFFF7FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"23945\n"); - end - xrf = 64'hC0A2000000000FFF; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"24559\n"); - end - xrf = 64'h0000000000000000; - y = 64'h453FFFFC001FFFFF; - zrf = 64'h313867979581E16A; - ans = 64'h313867979581E16A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"25173\n"); - end - xrf = 64'h419000000007FFF0; - y = 64'h4340000000000000; - zrf = 64'hC7FFFFDFF7FFFFFF; - ans = 64'hC7FFFFDFF7FFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"25787\n"); - end - xrf = 64'h0000000000000000; - y = 64'hA5FFFFFFDFFFFFFE; - zrf = 64'h4000000000000000; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"26401\n"); - end - xrf = 64'hB80000000000047F; - y = 64'hC7EFFFFFFFDFFEFF; - zrf = 64'hBFEF800000000FFF; - ans = 64'h3FF03FFFFFDFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"27015\n"); - end - xrf = 64'h0000000000000000; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"27629\n"); - end - xrf = 64'h86A0000000050000; - y = 64'h2AD69B1275E503A0; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"28243\n"); - end - xrf = 64'h0000000000000000; - y = 64'h7FE0000000000000; - zrf = 64'hBFF82D736AB2577D; - ans = 64'hBFF82D736AB2577D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"28857\n"); - end - xrf = 64'h43DD6D4736825F34; - y = 64'h11E0080000000200; - zrf = 64'hB2E0000000020000; - ans = 64'hB2E0000000020000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"29471\n"); - end - xrf = 64'hB7EE3604B4C64B15; - y = 64'h7FE0000000000001; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"30085\n"); - end - xrf = 64'h0000000000000000; - y = 64'hC00FBFFFFFFFFFFE; - zrf = 64'h4010000400020000; - ans = 64'h4010000400020000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"30699\n"); - end - xrf = 64'hBE1200001FFFFFFF; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h40E56C3F5EA1E0BD; - ans = 64'hFE1200001FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"31313\n"); - end - xrf = 64'h0000000000000000; - y = 64'h47F44C67CE14725C; - zrf = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"31927\n"); - end - xrf = 64'hBF4F00000000001E; - y = 64'hC1EFFFFFFFFFF000; - zrf = 64'hB4B05C323E215212; - ans = 64'h414EFFFFFFFFF09E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"32541\n"); - end - xrf = 64'h0000000000000000; - y = 64'h7FF0000000000001; - zrf = 64'hC000000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"33155\n"); - end - xrf = 64'hBFE828460CDF6B0D; - y = 64'hADAFFBFFFFFFFFFF; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h2DA82541041DCF1F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"33769\n"); - end - xrf = 64'h0000000000000000; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h4007FFFFFFFFFC00; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"34383\n"); - end - xrf = 64'hC7FFFFFFFFFFFFE7; - y = 64'hC7EFFFFEFFFFFFF8; - zrf = 64'hBFF0003C00000000; - ans = 64'h4FFFFFFEFFFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"34997\n"); - end - xrf = 64'hBC500BFFFFFFFFFF; - y = 64'h8000000000000000; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"35611\n"); - end - xrf = 64'h0000000000000000; - y = 64'hC01000000000080E; - zrf = 64'hCE9F800000FFFFFF; - ans = 64'hCE9F800000FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"36225\n"); - end - xrf = 64'h47EC1A9C03D9ECB8; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hBEDFFFFFFF7DFFFF; - ans = 64'hBEDFFFFFFF7DFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"36839\n"); - end - xrf = 64'h0000000000000000; - y = 64'h7FF00000FFFFFFFF; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h7FF80000FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"37453\n"); - end - xrf = 64'hBFCFFFFFFFFFF002; - y = 64'hC6700000003BFFFE; - zrf = 64'hBFFFDFFFDFFFFFFF; - ans = 64'h46500000003BF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"38067\n"); - end - xrf = 64'h0000000000000000; - y = 64'h8010000000000000; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"38681\n"); - end - xrf = 64'hB7F000008000001F; - y = 64'h4023FFFC00000000; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hB823FFFC9FFFE027; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"39295\n"); - end - xrf = 64'h0000000000000000; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h380100000000003E; - ans = 64'h380100000000003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"39909\n"); - end - xrf = 64'h3EF00000000004FF; - y = 64'hC35FFFBFFFFFFFEF; - zrf = 64'h800B04413DF080C3; - ans = 64'hC25FFFC0000009ED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"40523\n"); - end - xrf = 64'h407F00003FFFFFFF; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"41137\n"); - end - xrf = 64'h0000000000000000; - y = 64'h7FDFFFFFEFFFFF00; - zrf = 64'hB7F0000000021000; - ans = 64'hB7F0000000021000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"41751\n"); - end - xrf = 64'hBFDFF7FFFFF7FFFF; - y = 64'hBCA0000000000001; - zrf = 64'hC7F82F3AAACD8D77; - ans = 64'hC7F82F3AAACD8D77; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"42365\n"); - end - xrf = 64'h0000000000000000; - y = 64'hC5B0004000000100; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"42979\n"); - end - xrf = 64'hBFF000FF7FFFFFFF; - y = 64'h48BDFFFF7FFFFFFF; - zrf = 64'h3F671AAF77E7002B; - ans = 64'hC8BE01DE8FF803FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"43593\n"); - end - xrf = 64'h0000000000000000; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hBFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"44207\n"); - end - xrf = 64'h800FFFFF807FFFFF; - y = 64'h43F0000000000005; - zrf = 64'h8000000000000000; - ans = 64'h840FFFFF01000008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"44821\n"); - end - xrf = 64'h0000000000000000; - y = 64'hBFD0000000000001; - zrf = 64'hECAFFFFFF7FFFFEE; - ans = 64'hECAFFFFFF7FFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"45435\n"); - end - xrf = 64'h6010000000007DFF; - y = 64'h3E93A970CD45CF6F; - zrf = 64'h480391CF914CBF65; - ans = 64'h5EB3A970CD466A44; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"46049\n"); - end - xrf = 64'hC02FFFFFFCFFFFFF; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hC010000000000000; - ans = 64'h400FFFFFF9FFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"46663\n"); - end - xrf = 64'h0000000000000000; - y = 64'h3999E763325E2F3C; - zrf = 64'hC04495126EB489F2; - ans = 64'hC04495126EB489F2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"47277\n"); - end - xrf = 64'h3EB000040003FFFF; - y = 64'hBFE0000000000000; - zrf = 64'h34D7185B3B3DEA47; - ans = 64'hBEA000040003FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"47891\n"); - end - xrf = 64'h0000000000000000; - y = 64'hC06FFFFFF7FFDFFF; - zrf = 64'h3FD0000000000000; - ans = 64'h3FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"48505\n"); - end - xrf = 64'h3FEFFFFF7FFFFFFD; - y = 64'h3B7FFC0001FFFFFE; - zrf = 64'h7FD000000200001F; - ans = 64'h7FD000000200001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"49119\n"); - end - xrf = 64'h0000000000000000; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"49733\n"); - end - xrf = 64'hBE0FFDFFFFDFFFFF; - y = 64'h3F8FFFF80007FFFF; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"50347\n"); - end - xrf = 64'h0000000000000000; - y = 64'hBFF0000000000000; - zrf = 64'h3FB0000000000801; - ans = 64'h3FB0000000000801; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"50961\n"); - end - xrf = 64'h40FC000FFFFFFFFF; - y = 64'hC7EFFFBFFFFFF7FF; - zrf = 64'h3D4FFFFFFFFF87FF; - ans = 64'hC8FBFFD7FFDFF8FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"51575\n"); - end - xrf = 64'hC1E000000005FFFF; - y = 64'hBFF0000000000001; - zrf = 64'hC000000000000001; - ans = 64'h41DFFFFFFF8C0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"52189\n"); - end - xrf = 64'h0000000000000000; - y = 64'h380C1CB161614663; - zrf = 64'hC051FFFFFFFF7FFF; - ans = 64'hC051FFFFFFFF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"52803\n"); - end - xrf = 64'hB9A00000007FFDFE; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hC1D80003FFFFFFFF; - ans = 64'hC1D80003FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"53417\n"); - end - xrf = 64'h0000000000000000; - y = 64'h434FF0000003FFFE; - zrf = 64'h3CA0000000000001; - ans = 64'h3CA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"54031\n"); - end - xrf = 64'hB9C000000400001F; - y = 64'hC01FFFFEFC000000; - zrf = 64'hC1D00007FFFFFBFF; - ans = 64'hC1D00007FFFFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"54645\n"); - end - xrf = 64'h0000000000000000; - y = 64'hC000000000000001; - zrf = 64'hBFD0000000000001; - ans = 64'hBFD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"55259\n"); - end - xrf = 64'h414E31CF11CCD625; - y = 64'h4000000000000081; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"55873\n"); - end - xrf = 64'h0000000000000000; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'hFFD0000002FFFFFF; - ans = 64'hFFD0000002FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"56487\n"); - end - xrf = 64'h7FF0000000000040; - y = 64'hC00255D9EE601C85; - zrf = 64'h4026389D5E21B837; - ans = 64'h7FF8000000000040; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"57101\n"); - end - xrf = 64'h41E0000003FFE000; - y = 64'hC010000000000000; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hC2000000040FE000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"57715\n"); - end - xrf = 64'h0000000000000000; - y = 64'hC1F080000003FFFF; - zrf = 64'hBFCFFEFFEFFFFFFF; - ans = 64'hBFCFFEFFEFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"58329\n"); - end - xrf = 64'hC1EE67D76FC4673E; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h4DF044E1B605B6E2; - ans = 64'h4DF044E1B605B6E2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"58943\n"); - end - xrf = 64'h0000000000000000; - y = 64'hBF9004000000000F; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h001FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"59557\n"); - end - xrf = 64'h43CF600000000000; - y = 64'hC7E000FFFFF80000; - zrf = 64'hC3F3F7FFFFFFFFFF; - ans = 64'hCBBF61F5FFF05000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"60171\n"); - end - xrf = 64'h0000000000000000; - y = 64'hC340000000000000; - zrf = 64'hBCAFFFFFFFFFFFFF; + x = 64'h0000000000000000; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; ans = 64'hBCAFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -4664,19 +150,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -4692,12 +178,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"60785\n"); + $fwrite(fp,"6041\n"); end - xrf = 64'h49F0000000000077; - y = 64'hBFE0000000000800; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'hC9E0000000000877; + x = 64'h36E0000000000028; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h3CA00008000FFFFE; + ans = 64'h3CA00008000FFFFE; rn = 1; rz = 0; rm = 0; @@ -4711,19 +197,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -4739,12 +225,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"61399\n"); + $fwrite(fp,"8055\n"); end - xrf = 64'h0000000000000000; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hC7EFFFC000003FFF; - ans = 64'hC7EFFFC000003FFF; + x = 64'hC0301FBFFFFFFFFF; + y = 64'h401000000000FFC0; + z = 64'hDB30000000020040; + ans = 64'hDB30000000020040; rn = 1; rz = 0; rm = 0; @@ -4758,19 +244,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -4786,12 +272,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"62013\n"); + $fwrite(fp,"10069\n"); end - xrf = 64'h3FE0008FFFFFFFFF; - y = 64'h400B829FD71AD041; - zrf = 64'h3E4F6B8CA9EEBB1D; - ans = 64'h3FFB839772A6D1C6; + x = 64'h0000000000000000; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; rn = 1; rz = 0; rm = 0; @@ -4805,19 +291,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -4833,12 +319,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"62627\n"); + $fwrite(fp,"12083\n"); end - xrf = 64'h41E008001FFFFFFF; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hC54008001FFFFFFE; + x = 64'hA62FFFDBFFFFFFFE; + y = 64'h3FE0000000000001; + z = 64'hC1DFF7FC00000000; + ans = 64'hC1DFF7FC00000000; rn = 1; rz = 0; rm = 0; @@ -4852,19 +338,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -4880,12 +366,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"63241\n"); + $fwrite(fp,"14097\n"); end - xrf = 64'h0000000000000000; - y = 64'hBF70000010000020; - zrf = 64'hBF18000200000000; - ans = 64'hBF18000200000000; + x = 64'hBFD03FFFFFFFFFF0; + y = 64'h7FD6B970DE38813E; + z = 64'h3ECFEFFFFFFFFE00; + ans = 64'hFFB71456A1B1632C; rn = 1; rz = 0; rm = 0; @@ -4899,19 +385,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -4927,2173 +413,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"63855\n"); + $fwrite(fp,"16111\n"); end - xrf = 64'h6F4FFFF7FFFFF7FE; - y = 64'hFFE0000000000001; - zrf = 64'h3E4FFFFFFFFFFFF3; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"64469\n"); - end - xrf = 64'h0000000000000000; - y = 64'h3FEFE000000007FF; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h000FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"65083\n"); - end - xrf = 64'hB42007FFFFFF7FFF; - y = 64'h3FF0001FFFFFFFFE; - zrf = 64'hC3FFFFFFFFF87FFE; - ans = 64'hC3FFFFFFFFF87FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"65697\n"); - end - xrf = 64'h0000000000000000; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h801FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"66311\n"); - end - xrf = 64'h406FFFFFFFDF0000; - y = 64'h3EF003FFFFFFFFFA; - zrf = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"66925\n"); - end - xrf = 64'h0000000000000000; - y = 64'hFFF0000000000001; - zrf = 64'h3FA0000EFFFFFFFE; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"67539\n"); - end - xrf = 64'h407FFDFFEFFFFFFE; - y = 64'hBBAFFFBFFFFFBFFE; - zrf = 64'h4300000400000FFF; - ans = 64'h4300000400000FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"68153\n"); - end - xrf = 64'h4014000FFFFFFFFF; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hBFE0000000000000; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"68767\n"); - end - xrf = 64'h0000000000000000; - y = 64'h8000200000000FFF; - zrf = 64'h480FF800000007FE; - ans = 64'h480FF800000007FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"69381\n"); - end - xrf = 64'h3CA4F5D8A9F2E2BD; - y = 64'h0000000000000000; - zrf = 64'h3F0C0001FFFFFFFF; - ans = 64'h3F0C0001FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"69995\n"); - end - xrf = 64'h0000000000000001; - y = 64'h37FFFFFFBFFF7FFF; - zrf = 64'h0000000000000000; - ans = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"70609\n"); - end - xrf = 64'hBFB0027907AD9078; - y = 64'h46901000000001FE; - zrf = 64'hC3E91A11BDC49CCC; - ans = 64'hC650127B80B5723B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"71223\n"); - end - xrf = 64'h0000000000000001; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h8010000000000000; - ans = 64'h8010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"71837\n"); - end - xrf = 64'hB800000007FFF7FF; - y = 64'h400FFFFDFFFFFF00; - zrf = 64'h4010000000000001; - ans = 64'h4010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"72451\n"); - end - xrf = 64'h0000000000000001; - y = 64'h0010000000000000; - zrf = 64'hE20A6BB7018E117C; - ans = 64'hE20A6BB7018E117C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"73065\n"); - end - xrf = 64'hB87FFFFF8FFFFFFE; - y = 64'h3FC00001FFFFDFFF; - zrf = 64'hC7E0007FFFFFFFEF; - ans = 64'hC7E0007FFFFFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"73679\n"); - end - xrf = 64'hC3D000000000FBFF; - y = 64'h0010000000000001; - zrf = 64'hBFD0000000000001; - ans = 64'hBFD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"74293\n"); - end - xrf = 64'h0000000000000001; - y = 64'h801FFFFFFE00000E; - zrf = 64'hFFD000000FDFFFFF; - ans = 64'hFFD000000FDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"74907\n"); - end - xrf = 64'h2B4FFEFFFFFFBFFF; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h41EFFFFFEFFFFFFE; - ans = 64'h41EFFFFFEFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"75521\n"); - end - xrf = 64'h0000000000000001; - y = 64'hC0886A6D27B660AD; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"76135\n"); - end - xrf = 64'hBEC00000004000FF; - y = 64'hFFFFFE00000000FF; - zrf = 64'h404C9C600D9E0B67; - ans = 64'hFFFFFE00000000FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"76749\n"); - end - xrf = 64'h0000000000000001; - y = 64'h3CA0000000000001; - zrf = 64'h8000000000000001; - ans = 64'h8000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"77363\n"); - end - xrf = 64'h3FF000043FFFFFFF; - y = 64'hC04254549FAA7BB9; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'hC04054597E10F621; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"77977\n"); - end - xrf = 64'h0000000000000001; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'hBFD0000000004200; - ans = 64'hBFD0000000004200; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"78591\n"); - end - xrf = 64'hC1C0000FFDFFFFFF; - y = 64'hE9100000027FFFFF; - zrf = 64'h350FBFFFC0000000; - ans = 64'h6AE000100080027E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"79205\n"); - end - xrf = 64'hFFF07FFFFFFFFFFB; - y = 64'h3FD0000000000000; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hFFF87FFFFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"79819\n"); - end - xrf = 64'h0000000000000001; - y = 64'hC030000000003F00; - zrf = 64'hFFE1B726A50BCA05; - ans = 64'hFFE1B726A50BCA05; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"80433\n"); - end - xrf = 64'hC80FFFFF83FFFFFF; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hB7FFFFFF7FFFFFFE; - ans = 64'hC7FFFFFF83FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"81047\n"); - end - xrf = 64'h0000000000000001; - y = 64'h833DFFF7FFFFFFFE; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"81661\n"); - end - xrf = 64'hBFC17DF54982AC71; - y = 64'h3A1F000008000000; - zrf = 64'h37E1000000000FFF; - ans = 64'hB9F0F205A38D9460; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"82275\n"); - end - xrf = 64'h0000000000000001; - y = 64'h3FE0000000000000; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"82889\n"); - end - xrf = 64'hC80FFFFFEFFFFFDF; - y = 64'hAE2FE00007FFFFFE; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h3FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"83503\n"); - end - xrf = 64'h0000000000000001; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h3F39D2473C5B08B5; - ans = 64'h3F39D2473C5B08B5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"84117\n"); - end - xrf = 64'hB1CFEDFFFFFFFFFF; - y = 64'hFFF000077FFFFFFF; - zrf = 64'h8020000000200002; - ans = 64'hFFF800077FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"84731\n"); - end - xrf = 64'h3E280000000FFFFF; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h3E280000000FFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"85345\n"); - end - xrf = 64'h0000000000000001; - y = 64'h7FDFFFFEFFFFFFBF; - zrf = 64'h4000000000080004; - ans = 64'h4000000000080005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"85959\n"); - end - xrf = 64'h40200008001FFFFE; - y = 64'h3FF0000000000001; - zrf = 64'h3F6FFFFFFEFFFF7F; - ans = 64'h40200208001FEFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"86573\n"); - end - xrf = 64'h0000000000000001; - y = 64'h37EFFC0000000000; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"87187\n"); - end - xrf = 64'hFFF91C3BFB37550F; - y = 64'hBFE000020000007F; - zrf = 64'h402BFFFFF8000000; - ans = 64'hFFF91C3BFB37550F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"87801\n"); - end - xrf = 64'h0000000000000001; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"88415\n"); - end - xrf = 64'hC01B2E4B33B41899; - y = 64'hBDE0CE2A5F517DF6; - zrf = 64'h3FF0000000000000; - ans = 64'h3FF000000039190E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"89029\n"); - end - xrf = 64'h0000000000000001; - y = 64'h4000000000000001; - zrf = 64'hC3FFFFFFFFFF8006; - ans = 64'hC3FFFFFFFFFF8006; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"89643\n"); - end - xrf = 64'hFFD007FFFFFFFC00; - y = 64'hBCAD04958D1CA9A2; - zrf = 64'h3FC7FFFFFFFDFFFF; - ans = 64'h7C8D1317D7E330B6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"90257\n"); - end - xrf = 64'hE3F5D3ABA7E0799B; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h8010000000000000; - ans = 64'hE415D3ABA7E0799A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"90871\n"); - end - xrf = 64'h0000000000000001; - y = 64'hC3DED4D0B02CD6AA; - zrf = 64'h000C158AC12AC439; - ans = 64'h80BED1CB4D7C8BF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"91485\n"); - end - xrf = 64'h4F80041000000000; - y = 64'h4010000000000000; - zrf = 64'hB9F7BA96E673F02C; - ans = 64'h4FA0041000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"92099\n"); - end - xrf = 64'h0000000000000001; - y = 64'hC00FFFFFFFFFF807; - zrf = 64'hC340000000000000; + x = 64'h0000000000000000; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hC340000000000000; ans = 64'hC340000000000000; rn = 1; rz = 0; @@ -7108,19 +432,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -7136,12 +460,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"92713\n"); + $fwrite(fp,"18125\n"); end - xrf = 64'hB3DC67A3FC46B7D8; - y = 64'hC1CBE5E7797B2F35; - zrf = 64'h76AFC0000FFFFFFF; - ans = 64'h76AFC0000FFFFFFF; + x = 64'h7FD0021FFFFFFFFF; + y = 64'h4000000000000001; + z = 64'h000FFFFFFFF8001F; + ans = 64'h7FE0022000000000; rn = 1; rz = 0; rm = 0; @@ -7155,19 +479,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -7183,12 +507,59 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"93327\n"); + $fwrite(fp,"20139\n"); end - xrf = 64'h0000000000000001; + x = 64'hFFFFFFF00007FFFE; + y = 64'h405FFFFFFFFFF83F; + z = 64'hC39000000001001E; + ans = 64'hFFFFFFF00007FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"22153\n"); + end + x = 64'h0000000000000000; y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -7202,19 +573,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -7230,153 +601,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"93941\n"); + $fwrite(fp,"24167\n"); end - xrf = 64'hC3DFFFEDFFFFFFFF; - y = 64'h3FD0001FFFFFEFFF; - zrf = 64'h3FE0000000000001; - ans = 64'hC3C00016FFEDEFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"94555\n"); - end - xrf = 64'h0000000000000001; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h4340000023FFFFFF; - ans = 64'h4340000023FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"95169\n"); - end - xrf = 64'h40FFFDFF7FFFFFFF; - y = 64'hC34FFDFFFFFFFFEF; - zrf = 64'h7E0FFEFFFFEFFFFF; - ans = 64'h7E0FFEFFFFEFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"95783\n"); - end - xrf = 64'hC1DFFFFFFFFFFF7E; + x = 64'h3FB9E0877FECE6BA; y = 64'h4340000000000001; - zrf = 64'h8000000000000001; - ans = 64'hC52FFFFFFFFFFF80; + z = 64'h80203FFFFFFFFF7F; + ans = 64'h4309E0877FECE6BC; rn = 1; rz = 0; rm = 0; @@ -7390,19 +620,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -7418,12 +648,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"96397\n"); + $fwrite(fp,"26181\n"); end - xrf = 64'h0000000000000001; - y = 64'h3FF00003FFFEFFFF; - zrf = 64'hFFEFF000000001FF; - ans = 64'hFFEFF000000001FF; + x = 64'hC34E000020000000; + y = 64'h43C188DA7889EF54; + z = 64'h75FF807FFFFFFFFF; + ans = 64'h75FF807FFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -7437,19 +667,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -7465,247 +695,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"97011\n"); + $fwrite(fp,"28195\n"); end - xrf = 64'hC15000000010001F; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h47F55792228596A0; - ans = 64'h47F557922285969F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"97625\n"); - end - xrf = 64'h0000000000000001; - y = 64'hBFAAABC3854D8AAA; - zrf = 64'hC010000000000001; - ans = 64'hC010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"98239\n"); - end - xrf = 64'hB7E01FFFFFFFF800; - y = 64'hC7F2000000000003; - zrf = 64'hBFEF7FFEFFFFFFFF; - ans = 64'hBFDAB7FE000011F8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"98853\n"); - end - xrf = 64'h0000000000000001; - y = 64'h7FE0000000000001; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"99467\n"); - end - xrf = 64'hFFFFE0000000000E; - y = 64'hBCB0FFFFFFF7FFFF; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'hFFFFE0000000000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"100081\n"); - end - xrf = 64'h0000000000000001; + x = 64'h0000000000000000; y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h43C0000000FFFFFB; - ans = 64'h43C0000000FFFFFB; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -7719,19 +714,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -7747,59 +742,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"100695\n"); + $fwrite(fp,"30209\n"); end - xrf = 64'h46C5E1DB918AAA60; - y = 64'hC05FF77FFFFFFFFF; - zrf = 64'h3EEE3AB867132DBF; - ans = 64'hC735DC0B9338018A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"101309\n"); - end - xrf = 64'hC3EF7FF7FFFFFFFF; + x = 64'hFB9FF7FFFFFFFBFF; y = 64'h7FF0000000000000; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; + z = 64'hC34000013FFFFFFF; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -7813,19 +761,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -7841,12 +789,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"101923\n"); + $fwrite(fp,"32223\n"); end - xrf = 64'h0000000000000001; - y = 64'hFDD0000010000FFE; - zrf = 64'hC95336CB2C26A80E; - ans = 64'hC95336CB2C26A80E; + x = 64'hFFDFFFF7FFF00000; + y = 64'hBC7FE21CD2A54D1F; + z = 64'h43DFEFF000000000; + ans = 64'h7C6FE214DA0E2767; rn = 1; rz = 0; rm = 0; @@ -7860,19 +808,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -7888,247 +836,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"102537\n"); + $fwrite(fp,"34237\n"); end - xrf = 64'hC121216432DE4B7B; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h3FBE000000003FFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"103151\n"); - end - xrf = 64'h0000000000000001; - y = 64'h4446AF233378CEC0; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"103765\n"); - end - xrf = 64'h4050020000000100; - y = 64'h40F64E3F0BD07E03; - zrf = 64'h41E07FFFFFFFFFBF; - ans = 64'h41E08B288469D8BC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"104379\n"); - end - xrf = 64'h0000000000000001; - y = 64'h8000000000000000; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h401FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"104993\n"); - end - xrf = 64'h47EE78ADB65F42F6; - y = 64'h8638A91112ECACCA; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h3CAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"105607\n"); - end - xrf = 64'h0000000000000001; + x = 64'h0000000000000000; y = 64'h8000000000000001; - zrf = 64'h41F0010FFFFFFFFF; - ans = 64'h41F0010FFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; rn = 1; rz = 0; rm = 0; @@ -8142,19 +855,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -8170,153 +883,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"106221\n"); + $fwrite(fp,"36251\n"); end - xrf = 64'h3FD43D5700152CCF; - y = 64'h40DA29B21651007D; - zrf = 64'h3420000004003FFE; - ans = 64'h40C08C35EADAA763; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"106835\n"); - end - xrf = 64'h3FEFFFFFFFFFF0FF; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"107449\n"); - end - xrf = 64'h0000000000000001; - y = 64'hB81FFFC0007FFFFE; - zrf = 64'hC1C00000017FFFFF; - ans = 64'hC1C00000017FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"108063\n"); - end - xrf = 64'hBF8174D88196FAA3; + x = 64'hFFE00000001FFF00; y = 64'h8010000000000000; - zrf = 64'h381FFFFFEFFFFFFF; - ans = 64'h381FFFFFEFFFFFFF; + z = 64'h3FB9FFFFFFFFFFFF; + ans = 64'h4000D000001FFF00; rn = 1; rz = 0; rm = 0; @@ -8330,19 +902,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -8358,12 +930,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"108677\n"); + $fwrite(fp,"38265\n"); end - xrf = 64'h0000000000000001; - y = 64'h4010000003FFEFFF; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hBFFFFFFFFFFFFFFE; + x = 64'hC7E0800001000000; + y = 64'h41F0000007FFFFDF; + z = 64'hBFB0000080FFFFFF; + ans = 64'hC9E08000093FFFDE; rn = 1; rz = 0; rm = 0; @@ -8377,19 +949,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -8405,5557 +977,575 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"109291\n"); + $fwrite(fp,"40279\n"); end - xrf = 64'hEB2F000000000000; - y = 64'hA174D8D7ABF83504; - zrf = 64'hC2D90E3B93B7E7E0; - ans = 64'h4CB43210EE98735C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"109905\n"); - end - xrf = 64'h0000000000000001; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"110519\n"); - end - xrf = 64'hC1F367DA2CF3586B; - y = 64'hC1DF800000007FFF; - zrf = 64'h3CA0000000000000; - ans = 64'h43E31A3AC43FD8A8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"111133\n"); - end - xrf = 64'h0000000000000001; - y = 64'hBCA0000000000000; - zrf = 64'h3FDF5FE30D19D2F1; - ans = 64'h3FDF5FE30D19D2F1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"111747\n"); - end - xrf = 64'hC85F87FFFFFFFFFF; - y = 64'h45188A3DBE3CCC18; - zrf = 64'h3E6FFFFFFF01FFFF; - ans = 64'hCD882E3756B3681A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"112361\n"); - end - xrf = 64'h41E00000FFBFFFFF; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"112975\n"); - end - xrf = 64'h0000000000000001; - y = 64'h40001FFFFDFFFFFE; - zrf = 64'hC05FFFFFFF8007FF; - ans = 64'hC05FFFFFFF8007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"113589\n"); - end - xrf = 64'hC7F00000FFFFFBFF; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h38000000002007FE; - ans = 64'h44B00000FFFFFBFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"114203\n"); - end - xrf = 64'h0000000000000001; - y = 64'h404FFF7F7FFFFFFF; - zrf = 64'hBFF0000000000000; - ans = 64'hBFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"114817\n"); - end - xrf = 64'h3FF0000000040001; - y = 64'h381DCC6F8DD95714; - zrf = 64'hBFDE91054BF087B4; - ans = 64'hBFDE91054BF087B4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"115431\n"); - end - xrf = 64'h0000000000000001; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h4000000000000000; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"116045\n"); - end - xrf = 64'h55BA9A28FB6E818D; - y = 64'hC91FFFC000000200; - zrf = 64'h0010000000000001; - ans = 64'hDEEA99F3C71C8C5A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"116659\n"); - end - xrf = 64'h0000000000000001; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h801FFFFFFFFFBFC0; - ans = 64'h801FFFFFFFFFBFC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"117273\n"); - end - xrf = 64'h41D0000008003FFE; - y = 64'h38100000FFF7FFFF; - zrf = 64'h3CAFFFFBFFF80000; - ans = 64'h3CAFFFFBFFF80200; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"117887\n"); - end - xrf = 64'hC1F010000000000F; - y = 64'hBFE0000000000001; - zrf = 64'h4340000000000001; - ans = 64'h4340000040400001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"118501\n"); - end - xrf = 64'h0000000000000001; - y = 64'h3FB9B590EB570621; - zrf = 64'hC00FFFC00001FFFE; - ans = 64'hC00FFFC00001FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"119115\n"); - end - xrf = 64'h4220000000403FFF; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h3FF000200000003F; - ans = 64'hC2200000003E3FFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"119729\n"); - end - xrf = 64'h0000000000000001; - y = 64'h401003FFFFFFFF7F; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"120343\n"); - end - xrf = 64'h2890000100003FFF; - y = 64'hB83F246C2E31EA5B; - zrf = 64'h0D4001FFFFFFFFE0; - ans = 64'hA0DF246E207929CE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"120957\n"); - end - xrf = 64'h0000000000000001; - y = 64'hBFF0000000000001; - zrf = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"121571\n"); - end - xrf = 64'h3F0C00FFFFFFFFFF; - y = 64'hC7FFE0000000001F; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hC71BE4FF0000001A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"122185\n"); - end - xrf = 64'h0000000000000001; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'hBF9000000001FFF0; - ans = 64'hBF9000000001FFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"122799\n"); - end - xrf = 64'h3FE0013FFFFFFFFF; - y = 64'hC1DF7FFFE0000000; - zrf = 64'hBBEE000000000001; - ans = 64'hC1CF8275DFFD7FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"123413\n"); - end - xrf = 64'hBE900000E0000000; - y = 64'hC000000000000000; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h40200000100000E0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"124027\n"); - end - xrf = 64'h0000000000000001; - y = 64'h3FAFFBFFFFFFFDFF; - zrf = 64'hBFF0000000010800; - ans = 64'hBFF0000000010800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"124641\n"); - end - xrf = 64'hBFAFFFFF000007FE; - y = 64'hC000000000000001; - zrf = 64'hA698FCFB6D85D749; - ans = 64'h3FBFFFFF00000800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"125255\n"); - end - xrf = 64'h0000000000000001; - y = 64'hBFE0003FBFFFFFFF; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"125869\n"); - end - xrf = 64'hC0002000000001FE; - y = 64'h40144398EEDB1AB3; - zrf = 64'hA070000008000003; - ans = 64'hC0246C2020B8D36E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"126483\n"); - end - xrf = 64'h0000000000000001; - y = 64'hC010000000000000; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"127097\n"); - end - xrf = 64'h3816DC2B1E087754; - y = 64'h3F8FF807FFFFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"127711\n"); - end - xrf = 64'h0000000000000001; - y = 64'hC010000000000001; - zrf = 64'hC7E65A23395745B0; - ans = 64'hC7E65A23395745B0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"128325\n"); - end - xrf = 64'hBF7001FFFFFF7FFF; - y = 64'hC020000004000003; - zrf = 64'h3FC4ECED1B89DFEF; - ans = 64'h3FC8ED6D1C89DFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"128939\n"); - end - xrf = 64'h400FDFFFFFFFFFBE; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'hC03BDFFFFFFFFFBC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"129553\n"); - end - xrf = 64'h0000000000000001; - y = 64'h41D0FC9ED7065B94; - zrf = 64'h3CAFEFFFFFFF0000; - ans = 64'h3CAFEFFFFFFF0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"130167\n"); - end - xrf = 64'h43AFFFFFC0007FFE; - y = 64'hC340000000000000; - zrf = 64'h3FBFFFFBFFFFDFFE; - ans = 64'hC6FFFFFFC0007FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"130781\n"); - end - xrf = 64'h0000000000000001; - y = 64'h41CF7FFFFEFFFFFE; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hBCAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"131395\n"); - end - xrf = 64'h43FFFFFFFFFFFFFE; - y = 64'hBFD0001FF7FFFFFE; - zrf = 64'h3F4007FFFFFFFFF7; - ans = 64'hC3E0001FF7FFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"132009\n"); - end - xrf = 64'h0000000000000001; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"132623\n"); - end - xrf = 64'hB81FFFFFC000007F; - y = 64'h43DFFFFEFF7FFFFF; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"133237\n"); - end - xrf = 64'h0000000000000001; - y = 64'hFFE0000000000000; - zrf = 64'h40D4000040000000; - ans = 64'h40D4000040000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"133851\n"); - end - xrf = 64'h400AD4AEE5D49F38; - y = 64'hC1E8D952BE2C6406; - zrf = 64'h3FB11FFFFFFFFFFE; - ans = 64'hC204D5BACED9ABF5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"134465\n"); - end - xrf = 64'hC3F21524BE4E3979; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h4000000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"135079\n"); - end - xrf = 64'h0000000000000001; - y = 64'hC34FFFFFFFFFFE00; - zrf = 64'hC00C0000000001FF; - ans = 64'hC00C0000000001FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"135693\n"); - end - xrf = 64'hD17FFFFFFFFFFFF0; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h4010000000002FFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"136307\n"); - end - xrf = 64'h0000000000000001; - y = 64'h41D0FFFF00000000; - zrf = 64'hBCA0000000000000; - ans = 64'hBCA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"136921\n"); - end - xrf = 64'h3FF000000000200F; - y = 64'h41CFFFFFFC000000; - zrf = 64'h3FF000002000000F; - ans = 64'h41CFFFFFFC80401F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"137535\n"); - end - xrf = 64'h0000000000000001; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h3FD0000000000000; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"138149\n"); - end - xrf = 64'h4341FFFFFFFFFEFF; - y = 64'hBF748BF93240CAB0; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"138763\n"); - end - xrf = 64'h0000000000000001; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'hB8B000003F800000; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"139377\n"); - end - xrf = 64'hC17201583A2EF803; - y = 64'h40085B90C3F3027B; - zrf = 64'hBE4153CE82AFC214; - ans = 64'hC18B690EE5AD454B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"139991\n"); - end - xrf = 64'hC3E401FFFFFFFFFF; - y = 64'h0000000000000001; - zrf = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"140605\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hBFBFFDFFC0000000; - zrf = 64'h380000400FFFFFFE; - ans = 64'h380000400FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"141219\n"); - end - xrf = 64'h8E20000000000007; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h434FFFFFD7FFFFFF; - ans = 64'h434FFFFFD7FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"141833\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hB42F7FFFFFFFFE00; - zrf = 64'h8010000000000001; - ans = 64'h8010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"142447\n"); - end - xrf = 64'h4050000000002080; - y = 64'hC08FFFEFFFF00000; - zrf = 64'h4800200000000000; - ans = 64'h4800200000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"143061\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h0010000000000001; - zrf = 64'h3CA0000000000001; - ans = 64'h3CA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"143675\n"); - end - xrf = 64'h3FDFFFFFFFEFFFFD; - y = 64'hC1F0000005FFFFFF; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC35000002000000B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"144289\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h400000000003FE00; - ans = 64'h400000000003FE00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"144903\n"); - end - xrf = 64'h405773C1B923E530; - y = 64'h3FD0512CFDE7267D; - zrf = 64'hBF87997BF553F060; - ans = 64'h4037E7CA80DC7473; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"145517\n"); - end - xrf = 64'hC1EFFFFFFF803FFE; - y = 64'h3CA0000000000000; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FEFFFFF00000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"146131\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hC0AFFFFFFF80003F; - zrf = 64'hBACFFFFF7FFFEFFE; - ans = 64'hBACFFFFF7FFFEFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"146745\n"); - end - xrf = 64'h3FBFFDFFFFFFF800; - y = 64'h3CA0000000000001; - zrf = 64'h44AC4F8E8F747CBE; - ans = 64'h44AC4F8E8F747CBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"147359\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h3FCFFC007FFFFFFF; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h800C007FEFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"147973\n"); - end - xrf = 64'hC1C00008FFFFFFFF; - y = 64'h33E200000007FFFE; - zrf = 64'hFFA2FFFFFFFFFFFF; - ans = 64'hFFA2FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"148587\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h3FD0000000000000; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h0021FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"149201\n"); - end - xrf = 64'h3FEFFEFFFEFFFFFF; - y = 64'h3F1800000003FFFE; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01FFFE800C000BA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"149815\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h3FD0000000000001; - zrf = 64'h41FEFFFFFFFFFBFF; - ans = 64'h41FEFFFFFFFFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"150429\n"); - end - xrf = 64'h43F003FFFFE00000; - y = 64'h3FC03FFFFFFFBFFF; - zrf = 64'h3F100FFFFFFFFFFF; - ans = 64'h43C0440FFFDF3FEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"151043\n"); - end - xrf = 64'h80000FFFFFBFFFFF; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"151657\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h3FF46233694EE7EA; - zrf = 64'hC1F00002000003FF; - ans = 64'hC1F00002000003FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"152271\n"); - end - xrf = 64'h4F8FFFFFFFF9FFFF; - y = 64'h3FE0000000000000; - zrf = 64'h403DF104F345A123; - ans = 64'h4F7FFFFFFFF9FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"152885\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h4280008003FFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"153499\n"); - end - xrf = 64'hB77FFFBFFFFFFFF6; - y = 64'hAD73FFFFE0000000; - zrf = 64'h800702E5BA613332; - ans = 64'h2503FFD7E0003FFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"154113\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h001FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"154727\n"); - end - xrf = 64'h7FE0000000021FFF; - y = 64'h3C5FFFFFDFFF0000; - zrf = 64'hC010000000000000; - ans = 64'h7C4FFFFFE0033FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"155341\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h3FF0000000000000; - zrf = 64'hC3DFFBFFFFEFFFFF; - ans = 64'hC3DFFBFFFFEFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"155955\n"); - end - xrf = 64'h002EDA7062F2B653; - y = 64'hBF48C2B69C3CC227; - zrf = 64'hC01FFFFFFFFFFF82; - ans = 64'hC01FFFFFFFFFFF82; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"156569\n"); - end - xrf = 64'h686FFFFFF8000200; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h3FD0000000000000; - ans = 64'h687FFFFFF80001FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"157183\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hBF4FFFFBFFFFFFFC; - zrf = 64'hBFF03E0000000000; - ans = 64'hBFF03E0000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"157797\n"); - end - xrf = 64'h38019EFBBA34957E; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h41F55F86DA17B5B8; - ans = 64'h41F55F86DA17B5B8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"158411\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h3FF0000001000004; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"159025\n"); - end - xrf = 64'h40103FFFFFFFFFFD; - y = 64'h3FF000000001E000; - zrf = 64'h43C6885C3576B55B; - ans = 64'h43C6885C3576B55B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"159639\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h0000000000000000; - ans = 64'h002FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"160253\n"); - end - xrf = 64'hC3E0000000001010; - y = 64'h402FFFFBFF7FFFFF; - zrf = 64'hC000000000000001; - ans = 64'hC41FFFFBFF80201F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"160867\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hBF2EFFFFDFFFFFFF; - ans = 64'hBF2EFFFFDFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"161481\n"); - end - xrf = 64'hC06D269E93678E74; - y = 64'hC01FC2BEABDEFDBD; - zrf = 64'hC3C0001000FFFFFF; - ans = 64'hC3C0001000FFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"162095\n"); - end - xrf = 64'hF41FFFE00000007F; - y = 64'h4010000000000001; - zrf = 64'h3CA0000000000001; - ans = 64'hF43FFFE000000081; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"162709\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hBFF057662D37995D; - zrf = 64'hC1CFFFFFFFFFFFC2; - ans = 64'hC1CFFFFFFFFFFFC2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"163323\n"); - end - xrf = 64'h3817B6E353940A3E; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h3FAFFFFFFFF83FFF; - ans = 64'h3FAFFFFFFFF83FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"163937\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h3BE001FFFFFFEFFF; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"164551\n"); - end - xrf = 64'hC0D00000403FFFFF; - y = 64'h80204CCA9259A411; - zrf = 64'h5B900000203FFFFF; - ans = 64'h5B900000203FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"165165\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h4340000000000000; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"165779\n"); - end - xrf = 64'h41C29C47332872B1; - y = 64'h381FFFFF81FFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"166393\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'hB7E7FFFFFFFDFFFF; - ans = 64'hB7E7FFFFFFFDFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"167007\n"); - end - xrf = 64'h3812BA3824E4D9E0; - y = 64'hC00FFFFFFFEFFFFE; - zrf = 64'h3F493F24CFFC16BF; - ans = 64'h3F493F24CFFC16BF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"167621\n"); - end - xrf = 64'hC1CFFFFFFFFFFF7F; - y = 64'h7FE0000000000000; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"168235\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h7FFFFEFFFFFF8000; - zrf = 64'h43EFFFFF7FFFFFFE; - ans = 64'h7FFFFEFFFFFF8000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"168849\n"); - end - xrf = 64'hC3C523B80855F196; - y = 64'h7FE0000000000001; - zrf = 64'h400FFFEEFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"169463\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h3D600FFF7FFFFFFF; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"170077\n"); - end - xrf = 64'h38B0000000041000; - y = 64'h41D0FAA3D73DCB12; - zrf = 64'h41FFFF7FBFFFFFFF; - ans = 64'h41FFFF7FBFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"170691\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"171305\n"); - end - xrf = 64'hC00FFFFFFF7FFDFF; - y = 64'h41DFEFF800000000; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hC1FFEFF7FF903E20; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"171919\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h7FF0000000000001; - zrf = 64'h7FE5A216D1F18F5C; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"172533\n"); - end - xrf = 64'hBF54477471BBE4DC; - y = 64'h4A3DFFFFFFFFFFFC; - zrf = 64'hC1DFFFFFE03FFFFF; - ans = 64'hC9A302FD2AA0268C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"173147\n"); - end - xrf = 64'h33EFFFFFEFFFBFFF; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"173761\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hBFDBFFFFFFEFFFFE; - zrf = 64'hC00FFFFFFC040000; - ans = 64'hC00FFFFFFC040000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"174375\n"); - end - xrf = 64'h3FBFFFFFF8000200; - y = 64'h8000000000000000; - zrf = 64'hB802E70A9756F601; - ans = 64'hB802E70A9756F601; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"174989\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hBCD9BB552B097DCA; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h401FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"175603\n"); - end - xrf = 64'h3FFFFFE000FFFFFF; - y = 64'hBFBFFEFFFFFFFFFB; - zrf = 64'h380A0D5AA19EAA71; - ans = 64'hBFCFFEE001FFF7FA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"176217\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"176831\n"); - end - xrf = 64'hFFDC0000FFFFFFFF; - y = 64'hFDFFFFFFFFFFF801; - zrf = 64'hBFE0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"177445\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h8010000000000000; - zrf = 64'h402FFFFFFF800100; - ans = 64'h402FFFFFFF800100; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"178059\n"); - end - xrf = 64'h3D900EFFFFFFFFFF; - y = 64'hC36C60E0A6FAA0B9; - zrf = 64'h251FC7AE5368B48E; - ans = 64'hC10C7B7B79972BAE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"178673\n"); - end - xrf = 64'h41FFEFFFFFFFFDFE; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h0000000000000000; - ans = 64'h822FEFFFFFFFFDFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"179287\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hC0E000000001FFFD; - zrf = 64'hC1CFFFFFF0007FFF; - ans = 64'hC1CFFFFFF0007FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"179901\n"); - end - xrf = 64'hB7E0010000007FFF; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'hDE4FFFDFFFFF7FFE; - ans = 64'hDE4FFFDFFFFF7FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"180515\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h43480AE532861422; - zrf = 64'h4010000000000000; - ans = 64'h4010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"181129\n"); - end - xrf = 64'h407EBFEA5ED3E8F1; - y = 64'h43DBEA5EAAF280D9; - zrf = 64'hC3C93A8974B023EF; - ans = 64'h446ACCD5778018ED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"181743\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; + x = 64'h0000000000000000; y = 64'hBCA0000000000001; - zrf = 64'hC340000000000000; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"42293\n"); + end + x = 64'h43D0000000FE0000; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hC1D001FFFFFFFDFF; + ans = 64'hC1D00200FFFFFE0F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"44307\n"); + end + x = 64'h41EFFFFDFFFFFDFF; + y = 64'hFFFFFFFBFFEFFFFE; + z = 64'h7FF4282BA6C5B74F; + ans = 64'hFFFFFFFBFFEFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"46321\n"); + end + x = 64'h0000000000000000; + y = 64'hBFE0000000000000; + 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,"48335\n"); + end + x = 64'hB8016E821E7114DC; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hB7F000000001FFF7; + ans = 64'h37F2DD043CE029BF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"50349\n"); + end + x = 64'h43E85769B401F2FD; + y = 64'h4212E3E4695A36A4; + z = 64'hC020000002007FFF; + ans = 64'h460CBD0A941536A0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"52363\n"); + end + x = 64'h0000000000000000; + y = 64'hC000000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"54377\n"); + end + x = 64'h7FE33C0E42D7B972; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hBFF0007FDFFFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"56391\n"); + end + x = 64'hC3F94F46651EC7AE; + y = 64'hC3E3FFFFFFF00000; + z = 64'hB9EFFFFFDFFFFFFD; + ans = 64'h47EFA317FE4D2A53; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"58405\n"); + end + x = 64'h0000000000000000; + y = 64'hC340000000000000; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"60419\n"); + end + x = 64'hBE10000800000FFF; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hFFD9DB5021932540; + ans = 64'hFFD9DB5021932540; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"62433\n"); + end + x = 64'h43EF00001FFFFFFF; + y = 64'hC6BFFFFF00001FFE; + z = 64'hD720004001000000; + ans = 64'hD720004001000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"64447\n"); + end + x = 64'h0000000000000000; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hC340000000000000; ans = 64'hC340000000000000; rn = 1; rz = 0; @@ -13970,19 +1560,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -13998,1938 +1588,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"182357\n"); + $fwrite(fp,"66461\n"); end - xrf = 64'h48080001FFFFFFFE; - y = 64'h40E00000011FFFFF; - zrf = 64'hBFD0000000000001; - ans = 64'h48F8000201B00020; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"182971\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hB7F0E863BB89B480; - ans = 64'hB7F0E863BB89B480; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"183585\n"); - end - xrf = 64'h43D968AFF70E5E0C; - y = 64'h7D3000800000001F; - zrf = 64'hC3CDFFFFFFEFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"184199\n"); - end - xrf = 64'hC1AE5B70CEBC30DD; - y = 64'hBFD0000000000000; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"184813\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h40355F1CE077AB6A; - zrf = 64'h43F00000103FFFFF; - ans = 64'h43F00000103FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"185427\n"); - end - xrf = 64'h001FF80000100000; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h394000000040001E; - ans = 64'h394000000040001E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"186041\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hC01F7FFFFFFFFFFE; - zrf = 64'h4000000000000001; - ans = 64'h4000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"186655\n"); - end - xrf = 64'hFFDFFFFFFFFBBFFF; - y = 64'h7FEF000000000200; - zrf = 64'h400FF8000007FFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"187269\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hBFE0000000000000; - zrf = 64'hC010000000000001; - ans = 64'hC010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"187883\n"); - end - xrf = 64'hC1C00001FFFFFFF7; - y = 64'hC00E5D7AC1BB31DB; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h41DE5D7E8D6A8A01; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"188497\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hC0AFF7FF00000000; - ans = 64'hC0AFF7FF00000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"189111\n"); - end - xrf = 64'hB7F00000020003FF; - y = 64'h37F0000000077FFF; - zrf = 64'hC1F3DFFFFFFFFFFF; - ans = 64'hC1F3DFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"189725\n"); - end - xrf = 64'hB9F25F96065D1F51; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"190339\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hB7F8178C74E799A2; - zrf = 64'h3FB14A0681A30DCA; - ans = 64'h3FB14A0681A30DCA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"190953\n"); - end - xrf = 64'hB8002000000001FE; - y = 64'hBFF0000000000001; - zrf = 64'h400FFF800000000F; - ans = 64'h400FFF800000000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"191567\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hB80E000000010000; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"192181\n"); - end - xrf = 64'hFFEF50983C19207E; - y = 64'hB9CA0738168F7A54; - zrf = 64'hBFF7C2C7A0B00686; - ans = 64'h79C9788C353FC999; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"192795\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"193409\n"); - end - xrf = 64'h3F1C000000FFFFFE; - y = 64'h3F5FF7FFFFFDFFFF; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h3E8BF90000FDFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"194023\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hC000000000000001; - zrf = 64'h3FB0000800000003; - ans = 64'h3FB0000800000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"194637\n"); - end - xrf = 64'hC3CFE00000007FFF; - y = 64'hC1D01000000FFFFF; - zrf = 64'h3FFFFFFEFFFFFFFF; - ans = 64'h45AFFFE00020607D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"195251\n"); - end - xrf = 64'h47EA12AFD077048D; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC80A12AFD077048C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"195865\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hC80C919352460A7E; - zrf = 64'h43C4A5E1CCDA6E01; - ans = 64'h43C4A5E1CCDA6E01; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"196479\n"); - end - xrf = 64'h3F2CBAF78B0FA58F; - y = 64'hC010000000000000; - zrf = 64'h3CCD7C6CEDAF0060; - ans = 64'hBF4CBAF78B0F8813; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"197093\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hBFBFFDF7FFFFFFFF; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h3FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"197707\n"); - end - xrf = 64'h43D02FFFFFFFFFFE; - y = 64'h37F0000001FFFFFD; - zrf = 64'h3F9D452BB58B7274; - ans = 64'h3F9D452BB58B7274; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"198321\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hBFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"198935\n"); - end - xrf = 64'h41EFFFFFFFDFFFF0; - y = 64'h3F100000020001FE; - zrf = 64'h8010000000000000; - ans = 64'h4110000001F001F6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"199549\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hC340000000000000; - zrf = 64'hBFBFEFFBFFFFFFFF; - ans = 64'hBFBFEFFBFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"200163\n"); - end - xrf = 64'h3FEFFFFFFFFFFF83; - y = 64'hBFB005FFFFFFFFFE; - zrf = 64'h21E00000080003FE; - ans = 64'hBFB005FFFFFFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"200777\n"); - end - xrf = 64'h491FFFFFFFFFBFFF; - y = 64'hC340000000000001; - zrf = 64'hC340000000000000; - ans = 64'hCC6FFFFFFFFFC001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"201391\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hC010000020000400; - zrf = 64'h400FFFFF807FFFFF; - ans = 64'h400FFFFF807FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"202005\n"); - end - xrf = 64'hC1CFFE07FFFFFFFF; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h47A00000003DFFFF; - ans = 64'h47A00000003E1FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"202619\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h54200007FFFFE000; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"203233\n"); - end - xrf = 64'h4C2FFFFFFDFEFFFF; - y = 64'h480FFFFFFFF7E000; - zrf = 64'hC7E0000000FFFFF8; - ans = 64'h544FFFFFFDF6DFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"203847\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hFFE0000000000001; - zrf = 64'hBFF0000000000000; - ans = 64'hC008000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"204461\n"); - end - xrf = 64'h410E63FF6A5527C8; - y = 64'hB7E0B3FE678F16FD; - zrf = 64'h8000000000000001; - ans = 64'hB8FFB9E15BF4FE1E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"205075\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h000000000000007C; - ans = 64'hC00FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"205689\n"); - end - xrf = 64'h3FF0E30D389CC2AC; - y = 64'hC1FFFFFFEFFFFFFB; - zrf = 64'hA8D20000000003FF; - ans = 64'hC200E30D302B3C0D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"206303\n"); - end - xrf = 64'h480FFFFF7FFFFBFE; - y = 64'hFFF0000000000000; - zrf = 64'hC010000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"206917\n"); - end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'h413000007FFC0000; - zrf = 64'h7FFFFF8000000800; - ans = 64'h7FFFFF8000000800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"207531\n"); - end - xrf = 64'hC01FBFFFFFFFFFFC; + x = 64'h47EDBFD0A1EAAB89; y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h7FEF7FFFFBFFFFFF; + z = 64'h400FFFFFF7FFFDFF; ans = 64'hFFFFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -15944,19 +1607,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -15972,12 +1635,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"208145\n"); + $fwrite(fp,"68475\n"); end - xrf = 64'h000FFFFFFFFFFFFF; - y = 64'hC037A6B29B795033; - zrf = 64'h3FD0000000000001; - ans = 64'h3FD0000000000001; + x = 64'h400FFFF008000000; + y = 64'hC0140007FFFFFFFF; + z = 64'h3CA0FFFFFFFFEFFF; + ans = 64'hC033FFFE04FC01FF; rn = 1; rz = 0; rm = 0; @@ -15991,19 +1654,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -16019,247 +1682,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"208759\n"); + $fwrite(fp,"70489\n"); end - xrf = 64'h74501FFFE0000000; - y = 64'hFFDFF25176E4987F; - zrf = 64'h41F07FFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"209373\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h0000000000000000; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"209987\n"); - end - xrf = 64'hC3F0000001000002; - y = 64'h403FBFFFFFFFFFBF; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"210601\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'hB81FFFFFFFFF0002; - ans = 64'hB81FFFFFFFFF0002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"211215\n"); - end - xrf = 64'h7FF9CDC93C37E5CE; - y = 64'h144BFFFF80000000; - zrf = 64'h3FE800000001FFFE; - ans = 64'h7FF9CDC93C37E5CE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"211829\n"); - end - xrf = 64'hC03F80000000000E; + x = 64'h0000000000000001; y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -16273,19 +1701,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -16301,12 +1729,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"212443\n"); + $fwrite(fp,"72503\n"); end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'hC3E02000FFFFFFFE; - zrf = 64'h4351FFFF00000000; - ans = 64'h4351FFFF00000000; + x = 64'h47F0000800000FFF; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hB7F020000000007E; + ans = 64'hB7F020000000007E; rn = 1; rz = 0; rm = 0; @@ -16320,19 +1748,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -16348,12 +1776,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"213057\n"); + $fwrite(fp,"74517\n"); end - xrf = 64'h3FEFF7FFFBFFFFFF; - y = 64'h0010000000000001; - zrf = 64'hC7EFFFFFFFEFDFFE; - ans = 64'hC7EFFFFFFFEFDFFE; + x = 64'hB35E0000003FFFFF; + y = 64'h30DFFF6000000000; + z = 64'hBFCFFFFF7FFFF000; + ans = 64'hBFCFFFFF7FFFF000; rn = 1; rz = 0; rm = 0; @@ -16367,19 +1795,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -16395,11 +1823,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"213671\n"); + $fwrite(fp,"76531\n"); end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h50464308CED89F99; - zrf = 64'h3CAFFFFFFFFFFFFF; + x = 64'h0000000000000001; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; ans = 64'h3CAFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -16414,19 +1842,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -16442,12 +1870,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"214285\n"); + $fwrite(fp,"78545\n"); end - xrf = 64'h3C70000000FFF000; - y = 64'h3C6FFFFDF0000000; - zrf = 64'hC801BD5FB5B87EDD; - ans = 64'hC801BD5FB5B87EDD; + x = 64'h43DFE45B42DC9C12; + y = 64'h3FD0000000000001; + z = 64'h2DC0000100000008; + ans = 64'h43BFE45B42DC9C14; rn = 1; rz = 0; rm = 0; @@ -16461,19 +1889,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -16489,12 +1917,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"214899\n"); + $fwrite(fp,"80559\n"); end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFDFFFFFFFFFFFFF; + x = 64'hC676C2C0D7DB1BC4; + y = 64'hC7E3FFFFFFDFFFFF; + z = 64'h43CBF8649B07D35D; + ans = 64'h4E6C73710DA45D32; rn = 1; rz = 0; rm = 0; @@ -16508,19 +1936,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -16536,12 +1964,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"215513\n"); + $fwrite(fp,"82573\n"); end - xrf = 64'hC03FFFEFFBFFFFFF; - y = 64'h403FF7EFFFFFFFFF; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; + x = 64'h0000000000000001; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; rn = 1; rz = 0; rm = 0; @@ -16555,19 +1983,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -16583,764 +2011,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"216127\n"); + $fwrite(fp,"84587\n"); end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h3CA0000000000001; - zrf = 64'hBDAFF7EFFFFFFFFF; - ans = 64'hBDAFF7EFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"216741\n"); - end - xrf = 64'hB0700001FFDFFFFF; - y = 64'h47F0000000000010; - zrf = 64'hC0F824C774FC96AC; - ans = 64'hC0F824C774FC96AC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"217355\n"); - end - xrf = 64'h4C7FFFFC00004000; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'h493FFFFC00003FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"217969\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h4038FCF2DDB95CD2; - zrf = 64'h64F000000007FFF8; - ans = 64'h64F000000007FFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"218583\n"); - end - xrf = 64'h3E5E2E6A53E9291B; - y = 64'h3FD0000000000000; - zrf = 64'hC0ACC1E0EADB27EE; - ans = 64'hC0ACC1E0EADAEB91; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"219197\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h4EEFFFE000000020; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h0F0FFFE00000001C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"219811\n"); - end - xrf = 64'h40FBC1EF86378DB0; - y = 64'h3FD1000FFFFFFFFF; - zrf = 64'hBFB00BFFFFFFFFFE; - ans = 64'h40DD7E263D8A8CC1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"220425\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hBCAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"221039\n"); - end - xrf = 64'h47F74CDAF7D04AC1; - y = 64'h3FBDFFFFFFFFFF80; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"221653\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h3FE0000000000000; - zrf = 64'hC3C00007F8000000; - ans = 64'hC3C00007F8000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"222267\n"); - end - xrf = 64'h22FFFFFFFFFFBFFC; - y = 64'hFDA7FFFFC0000000; - zrf = 64'h3CAFFFFFFFFFE7FE; - ans = 64'hE0B7FFFFBFFFCFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"222881\n"); - end - xrf = 64'hD8D00000FFBFFFFF; - y = 64'h3FE0000000000001; - zrf = 64'hBFF0000000000000; - ans = 64'hD8C00000FFC00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"223495\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'hBCAFFFFBFFFFFFF7; - zrf = 64'hC28FFFFFF0003FFF; - ans = 64'hC28FFFFFF0003FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"224109\n"); - end - xrf = 64'h3FB2000000000400; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h47F7DD98F7C2DED1; - ans = 64'h47F7DD98F7C2DED1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"224723\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h3FBFFDFFFFFFFFEF; - zrf = 64'h0010000000000000; - ans = 64'h0011FFDFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"225337\n"); - end - xrf = 64'hBFB0000000280000; - y = 64'h41803F7FFFFFFFFF; - zrf = 64'h802465A3B9118621; - ans = 64'hC1403F8000289EBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"225951\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; + x = 64'hC3C0271F93496A51; y = 64'h3FF0000000000001; - zrf = 64'hBCA0000000000000; - ans = 64'hBCA0000000000000; + z = 64'hBFC339EF066EE599; + ans = 64'hC3C0271F93496A52; rn = 1; rz = 0; rm = 0; @@ -17354,19 +2030,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -17382,12 +2058,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"226565\n"); + $fwrite(fp,"86601\n"); end - xrf = 64'hBF8FFFE000020000; - y = 64'hC03FF000007FFFFF; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; + x = 64'hC023E6C8B89C7367; + y = 64'hC1FEFFFFFFFFFFFA; + z = 64'h9A52001FFFFFFFFF; + ans = 64'h4233479272D78FC8; rn = 1; rz = 0; rm = 0; @@ -17401,19 +2077,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -17429,200 +2105,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"227179\n"); + $fwrite(fp,"88615\n"); end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hC3D01F75DBA36D94; - ans = 64'hC3D01F75DBA36D94; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"227793\n"); - end - xrf = 64'hC80FFFFE000003FF; - y = 64'hAAC00000040001FF; - zrf = 64'h4AF74822E4CB078B; - ans = 64'h4AF74822E4CB078B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"228407\n"); - end - xrf = 64'hC6530B18D3D732F8; - y = 64'h4000000000000000; - zrf = 64'hBFE0000000000001; - ans = 64'hC6630B18D3D732F8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"229021\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h40D00000002FFFFE; - zrf = 64'hBF8FFFFF7EFFFFFE; - ans = 64'hBF8FFFFF7EFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"229635\n"); - end - xrf = 64'h2A1FFFFFFF7FFFFF; + x = 64'h0000000000000001; y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h582FFFFFFFFFFC01; - ans = 64'h582FFFFFFFFFFC01; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; rn = 1; rz = 0; rm = 0; @@ -17636,19 +2124,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -17664,106 +2152,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"230249\n"); + $fwrite(fp,"90629\n"); end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h41DFFFFFFFFFF900; - zrf = 64'h0000000000000001; - ans = 64'h01FFFFFFFFFFF8FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"230863\n"); - end - xrf = 64'h416A5A4987DB72F7; - y = 64'hBFCFFFFFFF7FFFF7; - zrf = 64'h3F90040FFFFFFFFF; - ans = 64'hC14A5A49857187C9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"231477\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; + x = 64'hCF6C878C67E3CCF9; y = 64'h4010000000000000; - zrf = 64'h8010000000000001; - ans = 64'h0027FFFFFFFFFFFC; + z = 64'hC0EFFFF804000000; + ans = 64'hCF8C878C67E3CCF9; rn = 1; rz = 0; rm = 0; @@ -17777,19 +2171,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -17805,12 +2199,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"232091\n"); + $fwrite(fp,"92643\n"); end - xrf = 64'hC02C30BECB2AD454; - y = 64'hBFBFFFFFFFE00400; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h40238617D961D4E3; + x = 64'h3FEFFFF77FFFFFFF; + y = 64'hBFC0003FFFFFFFBE; + z = 64'h40200000FFFBFFFF; + ans = 64'h401F800021F88800; rn = 1; rz = 0; rm = 0; @@ -17824,19 +2218,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -17852,200 +2246,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"232705\n"); + $fwrite(fp,"94657\n"); end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h43E0000000040400; - ans = 64'h43E0000000040400; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"233319\n"); - end - xrf = 64'h3FEFFFFFFFFF3FFF; - y = 64'h3FC89C5029E5BAE3; - zrf = 64'hBFFFFFFFFFFBFC00; - ans = 64'hBFFCEC75FABF5719; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"233933\n"); - end - xrf = 64'hBFF000000000004F; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hC02100000000004E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"234547\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h3F0FFFFE7FFFFFFE; - zrf = 64'h3FEFF00007FFFFFF; - ans = 64'h3FEFF00007FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"235161\n"); - end - xrf = 64'h37FA13DD98EDB441; + x = 64'h0000000000000001; y = 64'h4340000000000001; - zrf = 64'h81454CE0E2690CED; - ans = 64'h3B4A13DD98EDB443; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -18059,19 +2265,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -18087,12 +2293,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"235775\n"); + $fwrite(fp,"96671\n"); end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h43EFFFFFFFFF801E; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; + x = 64'hB94000000017FFFF; + y = 64'h7FE0000000000000; + z = 64'hBE5FFDBFFFFFFFFF; + ans = 64'hF93000000017FFFF; rn = 1; rz = 0; rm = 0; @@ -18106,19 +2312,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -18134,340 +2340,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"236389\n"); + $fwrite(fp,"98685\n"); end - xrf = 64'hC0007FFFFFFFBFFE; - y = 64'hBFDFFFFFFFFDFF80; - zrf = 64'hC2A2BD5FA60F3DDE; - ans = 64'hC2A2BD5FA60F3BCE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"237003\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h036FFFFFFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"237617\n"); - end - xrf = 64'h756FFFFFFC00003E; - y = 64'h3CF587D08EB672DD; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h727587D08C0578F5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"238231\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h7FE0000000000001; - zrf = 64'hC00FFFFFC0000002; - ans = 64'hBFFFFFFF80000006; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"238845\n"); - end - xrf = 64'h41F0000000008FFE; - y = 64'hB8000010FFFFFFFE; - zrf = 64'hBFFD9D819A979570; - ans = 64'hBFFD9D819A979570; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"239459\n"); - end - xrf = 64'h3111F5E51199ED7F; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'h7111F5E51199ED7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"240073\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'hC34E000000000200; - zrf = 64'h7FF0000000000C00; - ans = 64'h7FF8000000000C00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"240687\n"); - end - xrf = 64'h001000000200FFFF; - y = 64'h7FF0000000000000; - zrf = 64'h43D00FFFFFFFFFF7; + x = 64'h47F0007FFFFFFFFB; + y = 64'h7FD000007FFDFFFF; + z = 64'h41CFFFF00003FFFF; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -18482,19 +2359,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -18510,12 +2387,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"241301\n"); + $fwrite(fp,"100699\n"); end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'hC03C00000000003F; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; + x = 64'h0000000000000001; + y = 64'h7FF0000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h7FF8000000000001; rn = 1; rz = 0; rm = 0; @@ -18529,19 +2406,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -18557,153 +2434,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"241915\n"); + $fwrite(fp,"102713\n"); end - xrf = 64'h3F8FFFFF7F7FFFFE; - y = 64'hB1BFFBFFFFFFFFC0; - zrf = 64'h3C9FFFBFFFFFFF7F; - ans = 64'h3C9FFFBFFFFFFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"242529\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"243143\n"); - end - xrf = 64'h402A5DF48F98AD36; - y = 64'h381FFFFFFEFFFFFD; - zrf = 64'h4000000000000000; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"243757\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; + x = 64'hC12BFFFFFFFFFFBE; y = 64'h8000000000000000; - zrf = 64'hB33288221059078A; - ans = 64'hB33288221059078A; + z = 64'hC3C0000000000000; + ans = 64'hC3C0000000000000; rn = 1; rz = 0; rm = 0; @@ -18717,19 +2453,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -18745,12 +2481,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"244371\n"); + $fwrite(fp,"104727\n"); end - xrf = 64'h814931D84B67C1AA; - y = 64'h480FDFFFFFFC0000; - zrf = 64'h41F00FFFFDFFFFFF; - ans = 64'h41F00FFFFDFFFFFF; + x = 64'hC34000000001FBFF; + y = 64'hEC30000000001080; + z = 64'hBFFFFFFFFF7FF800; + ans = 64'h6F80000000020C7F; rn = 1; rz = 0; rm = 0; @@ -18764,19 +2500,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -18792,293 +2528,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"244985\n"); + $fwrite(fp,"106741\n"); end - xrf = 64'hC0F2D69C32093435; - y = 64'h8000000000000001; - zrf = 64'hBCA0000000000000; - ans = 64'hBCA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"245599\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'hBFDFFFFFF0200000; - zrf = 64'hC7FFD80000000000; - ans = 64'hC7FFD80000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"246213\n"); - end - xrf = 64'hB813FC0000000000; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h7FDFFFFEC0000000; - ans = 64'h7FDFFFFEC0000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"246827\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'hBBD1FFFFFFFFFFFF; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"247441\n"); - end - xrf = 64'h41C180E153D6F2EC; - y = 64'hC03F020000000000; - zrf = 64'h3FE7DDEDE7BDA1DF; - ans = 64'hC210F5F2574A7D06; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"248055\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; + x = 64'h0000000000000001; y = 64'h8010000000000001; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"248669\n"); - end - xrf = 64'h380C4BA9646D43BB; - y = 64'hBE06F94240DDBEA5; - zrf = 64'h3FF0000000000001; + z = 64'h3FF0000000000001; ans = 64'h3FF0000000000001; rn = 1; rz = 0; @@ -19093,19 +2547,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -19121,12 +2575,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"249283\n"); + $fwrite(fp,"108755\n"); end - xrf = 64'h000FFFFFFFFFFFFE; + x = 64'hC80FFFF800000000; y = 64'h801FFFFFFFFFFFFE; - zrf = 64'hC021000000000000; - ans = 64'hC021000000000000; + z = 64'hC0098E4ADD5BCBCE; + ans = 64'hC0098E4ADD5BCBCE; rn = 1; rz = 0; rm = 0; @@ -19140,19 +2594,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -19168,12 +2622,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"249897\n"); + $fwrite(fp,"110769\n"); end - xrf = 64'h3FD8B6FF3FCFD46E; - y = 64'h001FFFFFFFFFEFFF; - zrf = 64'hA97074FAD68B5F25; - ans = 64'hA97074FAD68B5F25; + x = 64'hB80FFFFFFFFFFFFE; + y = 64'h401FFBFFFFFFFFEE; + z = 64'h401000000000FDFF; + ans = 64'h401000000000FDFF; rn = 1; rz = 0; rm = 0; @@ -19187,19 +2641,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -19215,247 +2669,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"250511\n"); + $fwrite(fp,"112783\n"); end - xrf = 64'hB7EBFF0000000000; - y = 64'hBCA0000000000000; - zrf = 64'h8010000000000001; - ans = 64'h349BFF0000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"251125\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'hC96FFFFFFF8001FF; - zrf = 64'h40DFFFFFFDFFFFFC; - ans = 64'h40DFFFFFFDFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"251739\n"); - end - xrf = 64'h801C7B84A75451DD; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h43FFBFFDFFFFFFFF; - ans = 64'h43FFBFFDFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"252353\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h3FEBFC64B17CA8B8; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"252967\n"); - end - xrf = 64'h43FFFFFFFFFE003F; - y = 64'hB9BFFFDFFFF00000; - zrf = 64'hBE7E335C0C10AACF; - ans = 64'hBE7E375C0810A88F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"253581\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; + x = 64'h0000000000000001; y = 64'hBFD0000000000000; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; rn = 1; rz = 0; rm = 0; @@ -19469,19 +2688,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -19497,153 +2716,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"254195\n"); + $fwrite(fp,"114797\n"); end - xrf = 64'hC02FFFFFFEFFEFFF; - y = 64'hBA0FFFFF803FFFFF; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"254809\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'hBFD0000000000001; - zrf = 64'hC3F007DFFFFFFFFE; - ans = 64'hC3F007DFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"255423\n"); - end - xrf = 64'hB81B6C5020C693B9; - y = 64'h8010A73398D14A63; - zrf = 64'hBF9C0A2129066A92; - ans = 64'hBF9C0A2129066A92; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"256037\n"); - end - xrf = 64'hC3D0000000000FBE; + x = 64'hBF4C6D05FF900C3F; y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h43C0000000000FBD; + z = 64'h47FB82667FA1F31C; + ans = 64'h47FB82667FA1F31C; rn = 1; rz = 0; rm = 0; @@ -19657,19 +2735,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -19685,12 +2763,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"256651\n"); + $fwrite(fp,"116811\n"); end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h3E0FFFFC0003FFFE; - zrf = 64'h37EFFE0000000400; - ans = 64'h37EFFE0000000400; + x = 64'hC0003FFFFFFFFF7F; + y = 64'h37EFFFFFFE004000; + z = 64'h381E29836BC8D7F8; + ans = 64'h381609836C4AC7F8; rn = 1; rz = 0; rm = 0; @@ -19704,19 +2782,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -19732,340 +2810,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"257265\n"); + $fwrite(fp,"118825\n"); end - xrf = 64'h43EFBFFFFF000000; - y = 64'hBFE0000000000001; - zrf = 64'h402C00007FFFFFFF; - ans = 64'hC3DFBFFFFF000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"257879\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h41FFDFFFFFFFF000; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"258493\n"); - end - xrf = 64'h400FFFFFF9FFFFFE; - y = 64'hBFEFFFC000020000; - zrf = 64'h41E0000047FFFFFF; - ans = 64'h41E00000478000FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"259107\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"259721\n"); - end - xrf = 64'hC0170040464CFE1F; - y = 64'h311C000007FFFFFF; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"260335\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; + x = 64'h0000000000000001; y = 64'hBFF0000000000000; - zrf = 64'h43EFFFFF80000001; - ans = 64'h43EFFFFF80000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"260949\n"); - end - xrf = 64'hC023FFFFFBFFFFFE; - y = 64'hB7E56E0E64D01FD4; - zrf = 64'hB81306B461C19607; - ans = 64'h37FF0B765B9C3898; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"261563\n"); - end - xrf = 64'hFFE92C9C9F15452B; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h7FFFFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -20080,19 +2829,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -20108,5370 +2857,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"262177\n"); + $fwrite(fp,"120839\n"); end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h406FFFF80003FFFF; - zrf = 64'h8022000000000008; - ans = 64'h008FB7F80003FFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"262791\n"); - end - xrf = 64'h3DBFFFFFFC000000; - y = 64'hC000000000000000; - zrf = 64'h381FFFFFFFFDFFBF; - ans = 64'hBDCFFFFFFC000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"263405\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'hC1900000023FFFFF; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"264019\n"); - end - xrf = 64'hBFDFF0000000003F; - y = 64'hBFD00000000FBFFE; - zrf = 64'hE06FFFFFFFDBFFFF; - ans = 64'hE06FFFFFFFDBFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"264633\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h401FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"265247\n"); - end - xrf = 64'hC7E0000000007FEF; - y = 64'h381000FFF7FFFFFE; - zrf = 64'h3FD0000000000000; - ans = 64'hBFFC01FFF000FFEA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"265861\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'hD50FFFF7FFC00000; - ans = 64'hD50FFFF7FFC00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"266475\n"); - end - xrf = 64'hC3E8EC94F987EA69; - y = 64'hB6BFFE000007FFFF; - zrf = 64'h7FEFFFFFFBFFFFBF; - ans = 64'h7FEFFFFFFBFFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"267089\n"); - end - xrf = 64'hBF205FF2A7EAB3BB; - y = 64'hC010000000000001; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"267703\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'h47F0000000007FFD; - zrf = 64'h7FDFFFFFFFFFFFFF; - ans = 64'h7FDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"268317\n"); - end - xrf = 64'hB5A9CE7F4AAD3C58; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hBFE000000020000E; - ans = 64'hBFE000000020000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"268931\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'hC039B54B40228093; - zrf = 64'hC000000000000000; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"269545\n"); - end - xrf = 64'hBF8FFFFC007FFFFF; - y = 64'h43C00007FFFFFDFF; - zrf = 64'hBF60800FFFFFFFFE; - ans = 64'hC3600006003EFE1F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"270159\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'hC340000000000001; - zrf = 64'h4010000000000000; - ans = 64'h4010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"270773\n"); - end - xrf = 64'hBF400020007FFFFF; - y = 64'h801423605653ABED; - zrf = 64'h3CA0000000000001; - ans = 64'h3CA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"271387\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hC3C00000040FFFFF; - ans = 64'hC3C00000040FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"272001\n"); - end - xrf = 64'h3FDFFFFFFFFFFC04; - y = 64'hC3ED280F8FC308D0; - zrf = 64'hC890000000803FFF; - ans = 64'hC890000000803FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"272615\n"); - end - xrf = 64'h349FFFFFFFFDFFDF; - y = 64'hFFE0000000000000; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"273229\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'hC1D03FFFFFFFFFEF; - zrf = 64'hB7E598841B7B4A99; - ans = 64'hB7E598841B7B4A99; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"273843\n"); - end - xrf = 64'h2D8FFFFFFFFFFBBE; - y = 64'hFFE0000000000001; - zrf = 64'h403FC0003FFFFFFE; - ans = 64'hED7FFFFFFFFFFBC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"274457\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'hBFDFC00020000000; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"275071\n"); - end - xrf = 64'h41DFFFF7FFFFFFDE; - y = 64'hFFE0000FFFFF8000; - zrf = 64'h40357503F165F219; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"275685\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'hFFF0000000000000; - zrf = 64'h4000000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"276299\n"); - end - xrf = 64'hC2CC000003FFFFFE; - y = 64'h55E7FFFFFFFFFFEE; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'hD8C5000002FFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"276913\n"); - end - xrf = 64'h000FFFFFFFFFFFFE; - y = 64'hFFF0000000000001; - zrf = 64'hDD54F217C468808E; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"277527\n"); - end - xrf = 64'hBFC000000002FFFE; - y = 64'h401FFEFFFFFFFDFF; - zrf = 64'h405634FB9C49B286; - ans = 64'h4055F4FD9C49A68A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"278141\n"); - end - xrf = 64'hBFF080003FFFFFFE; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"278755\n"); - end - xrf = 64'h0010000000000000; - y = 64'h43D00FEFFFFFFFFF; - zrf = 64'hB06EA04ADE201D7F; - ans = 64'hB06EA04ADE201D7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"279369\n"); - end - xrf = 64'h43C04000000001FE; - y = 64'h0000000000000000; - zrf = 64'hEE69F3C54C8FF937; - ans = 64'hEE69F3C54C8FF937; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"279983\n"); - end - xrf = 64'h0010000000000000; - y = 64'hBFB418FF0ADFC0EF; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"280597\n"); - end - xrf = 64'hC0EFFFFFFF800200; - y = 64'h403000000080FFFF; - zrf = 64'h3FE0082386A444A3; - ans = 64'hC12FFFFEFFFFC994; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"281211\n"); - end - xrf = 64'h0010000000000000; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"281825\n"); - end - xrf = 64'h7260001FFF7FFFFF; - y = 64'h376FEBC83323C3E3; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h69DFEC0809B4CBE7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"282439\n"); - end - xrf = 64'h0010000000000000; - y = 64'h0010000000000000; - zrf = 64'hBC555EBEF2DFDF4F; - ans = 64'hBC555EBEF2DFDF4F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"283053\n"); - end - xrf = 64'hB9AFFFFFFEFFFFEF; - y = 64'hB8001FF800000000; - zrf = 64'h369A9A31438FD892; - ans = 64'h369A9A31438FD892; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"283667\n"); - end - xrf = 64'hF0DFFF800000FFFF; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h401FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"284281\n"); - end - xrf = 64'h0010000000000000; - y = 64'hA10FFFFFFFFFFFFF; - zrf = 64'hC1F312A8C47A6E98; - ans = 64'hC1F312A8C47A6E98; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"284895\n"); - end - xrf = 64'h3CAFFFFB00000000; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hBEAFFFDFFFFFFFFC; - ans = 64'hBEAFFFDFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"285509\n"); - end - xrf = 64'h0010000000000000; - y = 64'hB80FFFC000000100; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"286123\n"); - end - xrf = 64'hC3FFFFFFBFFF7FFF; - y = 64'hBF6200001FFFFFFE; - zrf = 64'hC0300000001FF7FF; - ans = 64'h4371FFFFFBFFB7BC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"286737\n"); - end - xrf = 64'h0010000000000000; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h3FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"287351\n"); - end - xrf = 64'hB54FFFF81FFFFFFF; - y = 64'h41C5D768F450EFAD; - zrf = 64'h0000000000000000; - ans = 64'hB725D763944E1B8C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"287965\n"); - end - xrf = 64'h0010000000000000; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h43DBFFFFFFFFE000; - ans = 64'h43DBFFFFFFFFE000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"288579\n"); - end - xrf = 64'hC3FFDFF7FFFFFFFF; - y = 64'hC139FA0B752F76EF; - zrf = 64'hBFCFFFDFFFFFF800; - ans = 64'h4549E00AEB376A2B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"289193\n"); - end - xrf = 64'h7783F12BB577FCCF; - y = 64'h3FD0000000000001; - zrf = 64'h4010000000000000; - ans = 64'h7763F12BB577FCD0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"289807\n"); - end - xrf = 64'h0010000000000000; - y = 64'h380E895E8EC54D4B; - zrf = 64'hC34000000807FFFF; - ans = 64'hC34000000807FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"290421\n"); - end - xrf = 64'h517A65ACF3CF57EB; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h80100007FFFFFFFF; - ans = 64'h516A65ACF3CF57EA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"291035\n"); - end - xrf = 64'h0010000000000000; - y = 64'h358FFFF000003FFF; - zrf = 64'hBFD0000000000000; - ans = 64'hBFD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"291649\n"); - end - xrf = 64'hB81628C1870235BB; - y = 64'h429AEA3DE2F34B36; - zrf = 64'h5DBFFFFFFFFEDFFF; - ans = 64'h5DBFFFFFFFFEDFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"292263\n"); - end - xrf = 64'h0010000000000000; - y = 64'h3FE0000000000001; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"292877\n"); - end - xrf = 64'hBF4A92FFF1A2C1E7; - y = 64'hFFFFFFFFFFFE007F; - zrf = 64'hFFF0000000000001; - ans = 64'hFFFFFFFFFFFE007F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"293491\n"); - end - xrf = 64'h0010000000000000; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h3FCFFFFFFFFFE7FE; - ans = 64'h3FCFFFFFFFFFE7FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"294105\n"); - end - xrf = 64'hBFC000FFFFFFFFEE; - y = 64'h3F5FEB520191C6A8; - zrf = 64'hC010FFFFFFFFFFE0; - ans = 64'hC011003FDAA16D44; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"294719\n"); - end - xrf = 64'h401040000000000E; - y = 64'h3FF0000000000000; - zrf = 64'h4000000000000001; - ans = 64'h401840000000000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"295333\n"); - end - xrf = 64'h0010000000000000; - y = 64'hC7E0000020FFFFFF; - zrf = 64'hC0348B6B6CA03F9F; - ans = 64'hC0348B6B6CA03F9F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"295947\n"); - end - xrf = 64'hC3D00021FFFFFFFF; - y = 64'h3FF0000000000001; - zrf = 64'hC2BFFFFFFFFFFFFE; - ans = 64'hC3D0002A00000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"296561\n"); - end - xrf = 64'h0010000000000000; - y = 64'hC1D0020100000000; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"297175\n"); - end - xrf = 64'h3FB003FFFFFFFFBE; - y = 64'hC7F5193A2A17F102; - zrf = 64'hCEAF8FFFFFFFFFFF; - ans = 64'hCEAF8FFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"297789\n"); - end - xrf = 64'h0010000000000000; - y = 64'h4000000000000000; - zrf = 64'h3FD0000000000001; - ans = 64'h3FD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"298403\n"); - end - xrf = 64'hBE4FFFFFFFC80000; - y = 64'hB80B00BB0700EEC9; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"299017\n"); - end - xrf = 64'h0010000000000000; - y = 64'h4000000000000001; - zrf = 64'h43DE9338EEC9F034; - ans = 64'h43DE9338EEC9F034; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"299631\n"); - end - xrf = 64'h47EA1AD664E290AD; - y = 64'h9228D0339D8A672A; - zrf = 64'hBB500FFFFFFFFFFA; - ans = 64'hBB500FFFFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"300245\n"); - end - xrf = 64'h47EFFFFFFFFE4000; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h480FFFFFFFFE3FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"300859\n"); - end - xrf = 64'h0010000000000000; - y = 64'h473C6A26FC8DE596; - zrf = 64'h3440003FFFFFFFF6; - ans = 64'h3440003FFFFFFFF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"301473\n"); - end - xrf = 64'hC7FBFFFFFFFFFE00; - y = 64'h4010000000000000; - zrf = 64'h3FC0000000000202; - ans = 64'hC81BFFFFFFFFFE00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"302087\n"); - end - xrf = 64'h0010000000000000; - y = 64'hC7EFFFFFFF700000; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h880FFFFFFF700000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"302701\n"); - end - xrf = 64'hBA24007FFFFFFFFF; - y = 64'hBFB0000008000002; - zrf = 64'hBC2000000800007E; - ans = 64'hBC20000007FEC076; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"303315\n"); - end - xrf = 64'h0010000000000000; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"303929\n"); - end - xrf = 64'hB7F02000000FFFFF; - y = 64'hBEBC2752FF417189; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"304543\n"); - end - xrf = 64'h0010000000000000; - y = 64'h4340000000000000; - zrf = 64'h403FFFF007FFFFFF; - ans = 64'h403FFFF007FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"305157\n"); - end - xrf = 64'h380FFFF0001FFFFE; - y = 64'hBFA4BF5ED9CE8C8E; - zrf = 64'h3FF01000001FFFFF; - ans = 64'h3FF01000001FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"305771\n"); - end - xrf = 64'h3FC001FFFFFFFF7F; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h432001FFFFFFFF80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"306385\n"); - end - xrf = 64'h0010000000000000; - y = 64'hC7F686065D1D267B; - zrf = 64'h800001000000FFFF; - ans = 64'h881686065D1D267B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"306999\n"); - end - xrf = 64'h43D0000080000000; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h6010007FFFFFFC00; - ans = 64'h6010007FFFFFFC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"307613\n"); - end - xrf = 64'h0010000000000000; - y = 64'hBF4FDFFFFFF7FFFE; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h801003FBFFFFFEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"308227\n"); - end - xrf = 64'hC3E4FFFFFFFFFFFE; - y = 64'hC0600002000003FF; - zrf = 64'h400F7FFFFFFFFE00; - ans = 64'h44550002A000053D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"308841\n"); - end - xrf = 64'h0010000000000000; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"309455\n"); - end - xrf = 64'hBFF0000040100000; - y = 64'hBFF0008000007FFF; - zrf = 64'hC340000000000000; - ans = 64'hC33FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"310069\n"); - end - xrf = 64'h0010000000000000; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hC7F0000FFF7FFFFE; - ans = 64'hC7F0000FFF7FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"310683\n"); - end - xrf = 64'hC1DFFFFFFFC0FFFF; - y = 64'h381FFFDFFFFF0000; - zrf = 64'hBFD2988A0956184C; - ans = 64'hBFD2988A0956184C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"311297\n"); - end - xrf = 64'hC01FFFFFEFFEFFFE; - y = 64'h7FF0000000000001; - zrf = 64'h3FE0000000000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"311911\n"); - end - xrf = 64'h0010000000000000; - y = 64'hBCA842CEA622C954; - zrf = 64'hFFD001FFFFFFEFFF; - ans = 64'hFFD001FFFFFFEFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"312525\n"); - end - xrf = 64'h402080003FFFFFFE; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h801F58D78CAAC986; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"313139\n"); - end - xrf = 64'h0010000000000000; - y = 64'hBE6FFFFFBFFFFFF7; - zrf = 64'h8000000000000000; - ans = 64'h800000000FFFFFE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"313753\n"); - end - xrf = 64'hBF7804A41F298DA7; - y = 64'hBFBD9545159D35EC; - zrf = 64'h37EFF807FFFFFFFE; - ans = 64'h3F46343E32A9AFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"314367\n"); - end - xrf = 64'h0010000000000000; - y = 64'h8000000000000001; - zrf = 64'h0010000000000000; - ans = 64'h0010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"314981\n"); - end - xrf = 64'h3C1FF7FFFFF7FFFF; - y = 64'hBF60040000080000; - zrf = 64'hC010000000000001; - ans = 64'hC010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"315595\n"); - end - xrf = 64'h0010000000000000; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h47F0000FFFFFFBFF; - ans = 64'h47F0000FFFFFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"316209\n"); - end - xrf = 64'hC3DE5E4460AC38DB; - y = 64'h400FFFFDFFFFF000; - zrf = 64'h7FEFFFFFFC00000F; - ans = 64'h7FEFFFFFFC00000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"316823\n"); - end - xrf = 64'hC35F7FFFF8000000; - y = 64'h8010000000000000; - zrf = 64'h3FD0000000000001; - ans = 64'h3FD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"317437\n"); - end - xrf = 64'h0010000000000000; - y = 64'hFFF0000007FFFF00; - zrf = 64'h508FFFFFFFFFE3FF; - ans = 64'hFFF8000007FFFF00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"318051\n"); - end - xrf = 64'h3065CB9EE72E8EAA; - y = 64'h8010000000000001; - zrf = 64'hC3F0000200000000; - ans = 64'hC3F0000200000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"318665\n"); - end - xrf = 64'h0010000000000000; - y = 64'h3FF080000000007F; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"319279\n"); - end - xrf = 64'h3F20000FFFFFFFBF; - y = 64'hBFFE378573394127; - zrf = 64'hC0603FC8BEC02138; - ans = 64'hC0603FCAA23A5BE4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"319893\n"); - end - xrf = 64'h0010000000000000; - y = 64'hBCA0000000000000; - zrf = 64'h0000000000000001; - ans = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"320507\n"); - end - xrf = 64'hE8400000047FFFFE; - y = 64'hFFD000100000001F; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"321121\n"); - end - xrf = 64'h0010000000000000; - y = 64'hBCA0000000000001; - zrf = 64'h2CBFFFF00FFFFFFF; - ans = 64'h2CBFFFF00FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"321735\n"); - end - xrf = 64'h401FFFFFFFFC3FFE; - y = 64'h43F0008FFFFFFFFE; - zrf = 64'hC3F2001000000000; - ans = 64'h441B811BFFFC3FD8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"322349\n"); - end - xrf = 64'h1D300047FFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"322963\n"); - end - xrf = 64'h0010000000000000; - y = 64'h41C0020000000007; - zrf = 64'h43F4002000000000; - ans = 64'h43F4002000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"323577\n"); - end - xrf = 64'h43C00000FFFEFFFF; - y = 64'hBFD0000000000000; - zrf = 64'h3E800FFFFFEFFFFE; - ans = 64'hC3A00000FFFEFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"324191\n"); - end - xrf = 64'h0010000000000000; - y = 64'h3FDFFFFFFFFFF7FC; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"324805\n"); - end - xrf = 64'hC04D419BE71CFD22; - y = 64'hC05FFFDFFFF7FFFF; - zrf = 64'hBCAB975B5FA2B241; - ans = 64'h40BD417EA579C59D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"325419\n"); - end - xrf = 64'h0010000000000000; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"326033\n"); - end - xrf = 64'hBFCEFFFFFFFFFFBF; - y = 64'hC03FFFFFFFFFFFE7; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'h4016FFFFFFFFFFA7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"326647\n"); - end - xrf = 64'h0010000000000000; - y = 64'hBFE0000000000000; - zrf = 64'hB76FFFFFFFDFFFDE; - ans = 64'hB76FFFFFFFDFFFDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"327261\n"); - end - xrf = 64'hFFEB046129238D38; - y = 64'h491FFFFBEFFFFFFF; - zrf = 64'h406FEDFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"327875\n"); - end - xrf = 64'hE900000000040003; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h6900000000040002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"328489\n"); - end - xrf = 64'h0010000000000000; - y = 64'hBFEFF000003FFFFF; - zrf = 64'hC80FFFFFFFFFBFEF; - ans = 64'hC80FFFFFFFFFBFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"329103\n"); - end - xrf = 64'h8001FFFFFFFFDFFF; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hC07FFFFFFF01FFFE; - ans = 64'hC07FFFFFFF01FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"329717\n"); - end - xrf = 64'h0010000000000000; - y = 64'h7FD00000007FFFFF; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"330331\n"); - end - xrf = 64'h403F800001000000; - y = 64'hB92FFDFFF7FFFFFE; - zrf = 64'hB80FF7FFFF7FFFFE; - ans = 64'hB97F7E08390FEFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"330945\n"); - end - xrf = 64'h0010000000000000; - y = 64'hBFF0000000000001; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"331559\n"); - end - xrf = 64'h9D3FFFFFFFF7E000; - y = 64'h6A9B80B7D3CB8215; - zrf = 64'hBFF0000000000000; - ans = 64'hC7EB80B7D3C48666; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"332173\n"); - end - xrf = 64'h0010000000000000; + x = 64'hF99FFFFFFFFBFFFB; y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h434FFFFFEFEFFFFE; - ans = 64'h434FFFFFEFEFFFFE; + z = 64'hBFE17FFFFFFFFFFF; + ans = 64'h79AFFFFFFFFBFFF9; rn = 1; rz = 0; rm = 0; @@ -25485,19 +2876,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -25513,12 +2904,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"332787\n"); + $fwrite(fp,"122853\n"); end - xrf = 64'hBFCFF7FFF7FFFFFF; - y = 64'h3560000007FFFFC0; - zrf = 64'h3F1FFE0000001FFF; - ans = 64'h3F1FFE0000001FFF; + x = 64'h43F00000000003FF; + y = 64'h303FFFE000000002; + z = 64'hBFF00000000083FF; + ans = 64'hBFF00000000083FF; rn = 1; rz = 0; rm = 0; @@ -25532,19 +2923,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -25560,247 +2951,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"333401\n"); + $fwrite(fp,"124867\n"); end - xrf = 64'hBFF08000003FFFFF; - y = 64'hC000000000000001; - zrf = 64'h0010000000000000; - ans = 64'h4000800000400000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"334015\n"); - end - xrf = 64'h0010000000000000; - y = 64'hC1FFFFFFF80007FF; - zrf = 64'hBF50000000003F7E; - ans = 64'hBF50000000003F7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"334629\n"); - end - xrf = 64'h4800000000000E00; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'hC00C758EB7D7F0E3; - ans = 64'hC820000000000DFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"335243\n"); - end - xrf = 64'h0010000000000000; - y = 64'hB81FFE0800000000; - zrf = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"335857\n"); - end - xrf = 64'h3FFF7FFFFFDFFFFF; - y = 64'h37F310487C36B9F7; - zrf = 64'h7FD0000021FFFFFE; - ans = 64'h7FD0000021FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"336471\n"); - end - xrf = 64'h0010000000000000; + x = 64'h0000000000000001; y = 64'hC010000000000000; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -25814,19 +2970,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -25842,59 +2998,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"337085\n"); + $fwrite(fp,"126881\n"); end - xrf = 64'h37E13C55FB73A123; - y = 64'hBBE423B0427AB4FB; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"337699\n"); - end - xrf = 64'h0010000000000000; + x = 64'hBE5BFFFFFFFFEFFE; y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hBFFFDFFFFFFFFDFE; - ans = 64'hBFFFDFFFFFFFFDFE; + z = 64'h3FF7C1136E8AA3CA; + ans = 64'h3FF7C113A68AA3CA; rn = 1; rz = 0; rm = 0; @@ -25908,19 +3017,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -25936,12 +3045,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"338313\n"); + $fwrite(fp,"128895\n"); end - xrf = 64'h000A56DAA543D820; - y = 64'hC7E008FFFFFFFFFF; - zrf = 64'hA4F0800007FFFFFF; - ans = 64'hA4F0800007FFFFFF; + x = 64'h409F8000003FFFFF; + y = 64'h3B6FEFFFFFFFFFFD; + z = 64'hC01001FFEFFFFFFF; + ans = 64'hC01001FFEFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -25955,19 +3064,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -25983,1938 +3092,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"338927\n"); + $fwrite(fp,"130909\n"); end - xrf = 64'h3FEFC00000100000; - y = 64'hC340000000000000; - zrf = 64'h0000000000000001; - ans = 64'hC33FC00000100000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"339541\n"); - end - xrf = 64'h0010000000000000; - y = 64'hC54FFFFFFF808000; - zrf = 64'h402C0000003FFFFF; - ans = 64'h402C0000003FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"340155\n"); - end - xrf = 64'hBDBFFFFF7FFF7FFF; - y = 64'hC340000000000001; - zrf = 64'h469C88C5CBAF8186; - ans = 64'h469C88C5CBAF8186; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"340769\n"); - end - xrf = 64'h0010000000000000; - y = 64'h401FFFFC00003FFF; - zrf = 64'h4010000000000001; - ans = 64'h4010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"341383\n"); - end - xrf = 64'h402FFFFFFDF80000; - y = 64'h00207FFFFFFBFFFE; - zrf = 64'hC80FFFFFFFF0000F; - ans = 64'hC80FFFFFFFF0000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"341997\n"); - end - xrf = 64'h0010000000000000; + x = 64'h0000000000000001; y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"342611\n"); - end - xrf = 64'h4008FFCC8CB379C8; - y = 64'h4020040000001000; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'h4038860C7FD6BFA6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"343225\n"); - end - xrf = 64'h0010000000000000; - y = 64'hFFE0000000000001; - zrf = 64'hC03A7FD2CBE40B24; - ans = 64'hC03C7FD2CBE40B24; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"343839\n"); - end - xrf = 64'h47F0040400000000; - y = 64'h3FD1FFFFFFFF7FFF; - zrf = 64'hE92013FFFFFFFFFE; - ans = 64'hE92013FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"344453\n"); - end - xrf = 64'h3FD0000080000004; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"345067\n"); - end - xrf = 64'h0010000000000000; - y = 64'h3FB3FFFFFFFFFEFE; - zrf = 64'hC090000000002FFF; - ans = 64'hC090000000002FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"345681\n"); - end - xrf = 64'hBFEFFFFFFFFBFFFC; - y = 64'hFFF0000000000000; - zrf = 64'hC1D53CF5FDF3680F; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"346295\n"); - end - xrf = 64'h0010000000000000; - y = 64'hC03000010000007F; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h400FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"346909\n"); - end - xrf = 64'hAB9FFFFFFFFFF1FE; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hC1C8E09D58BA6A9F; - ans = 64'hC1C8E09D58BA6A9F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"347523\n"); - end - xrf = 64'h0010000000000000; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"348137\n"); - end - xrf = 64'h40EFFFFFFFFDFFEE; - y = 64'hBFF0000000000000; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hC0EFFFFFFFFDFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"348751\n"); - end - xrf = 64'h0010000000000001; - y = 64'h0000000000000000; - zrf = 64'h001FFFFEFFFFFF7F; - ans = 64'h001FFFFEFFFFFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"349365\n"); - end - xrf = 64'h400040000007FFFE; - y = 64'hC020000081FFFFFE; - zrf = 64'hC1F6CE889A397A6A; - ans = 64'hC1F6CE889B3D7A72; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"349979\n"); - end - xrf = 64'h40BFFFC000080000; - y = 64'h0000000000000001; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"350593\n"); - end - xrf = 64'h0010000000000001; - y = 64'h7FDFFFDFEFFFFFFF; - zrf = 64'h0010003FFFFFFFC0; - ans = 64'h3FFFFFDFF0000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"351207\n"); - end - xrf = 64'h7FFFFFFFFFF7FF7F; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hB81018316CF58422; - ans = 64'h7FFFFFFFFFF7FF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"351821\n"); - end - xrf = 64'h0010000000000001; - y = 64'h21A0FEFFFFFFFFFF; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h3FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"352435\n"); - end - xrf = 64'hDF00000000FEFFFE; - y = 64'hC3C00000000FDFFF; - zrf = 64'h3F0FFFFFFFE80000; - ans = 64'h62D00000010EDFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"353049\n"); - end - xrf = 64'h0010000000000001; - y = 64'h0010000000000001; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"353663\n"); - end - xrf = 64'hBFC38CD9B19C294A; - y = 64'hBFCFFFFC3FFFFFFE; - zrf = 64'hBCA0000000000000; - ans = 64'h3FA38CD7671AA668; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"354277\n"); - end - xrf = 64'h0010000000000001; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hC0800800FFFFFFFE; - ans = 64'hC0800800FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"354891\n"); - end - xrf = 64'h4338F8B4D98D518E; - y = 64'h38101FFFFFFFEFFE; - zrf = 64'hFFD0003FFFFF8000; - ans = 64'hFFD0003FFFFF8000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"355505\n"); - end - xrf = 64'hC2EFFFFFFFFFD7FF; - y = 64'h3CA0000000000000; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"356119\n"); - end - xrf = 64'h0010000000000001; - y = 64'hBFEC8B10292FC3DD; - zrf = 64'hC1CFC000000001FE; - ans = 64'hC1CFC000000001FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"356733\n"); - end - xrf = 64'h77C00000000010FF; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h3FEFFFFDEFFFFFFE; - ans = 64'h74800000000010FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"357347\n"); - end - xrf = 64'h0010000000000001; - y = 64'hC7EFC00000000008; - zrf = 64'h3FF0000000000000; - ans = 64'h3FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"357961\n"); - end - xrf = 64'hB7ED1530D0EED500; - y = 64'hC0FFFFFC000000FF; - zrf = 64'hC1C613EAB1D2BC41; - ans = 64'hC1C613EAB1D2BC41; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"358575\n"); - end - xrf = 64'h0010000000000001; - y = 64'h3FD0000000000000; - zrf = 64'hC000000000000000; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"359189\n"); - end - xrf = 64'h4020001000000007; - y = 64'h39AFFFFFFFF7FFFE; - zrf = 64'h8010000000000001; - ans = 64'h39E0000FFFFC0002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"359803\n"); - end - xrf = 64'h0010000000000001; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h43405A4963156D9E; - ans = 64'h43405A4963156D9E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"360417\n"); - end - xrf = 64'h381004000000FFFF; - y = 64'hC03FFFFA00000000; - zrf = 64'h42F00000006FFFFF; - ans = 64'h42F00000006FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"361031\n"); - end - xrf = 64'hC800000000480000; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'hC340000000000001; - ans = 64'hC7F000000047FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"361645\n"); - end - xrf = 64'h0010000000000001; - y = 64'hBFCFFFFFFFFFFBFF; - zrf = 64'h4F5FFFFFDFFFFF7E; - ans = 64'h4F5FFFFFDFFFFF7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"362259\n"); - end - xrf = 64'h41E4A1EAE73D355C; - y = 64'h3FE0000000000001; - zrf = 64'h37E2ACB70B24ACB2; - ans = 64'h41D4A1EAE73D355D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"362873\n"); - end - xrf = 64'h0010000000000001; - y = 64'h802FFFFFBC000000; - zrf = 64'h3FE0000000000001; - ans = 64'h3FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"363487\n"); - end - xrf = 64'h403FFFE000FFFFFE; - y = 64'hFFFFFFFFFFBFFFF0; - zrf = 64'h402FFEFFFFFFBFFF; - ans = 64'hFFFFFFFFFFBFFFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"364101\n"); - end - xrf = 64'h0010000000000001; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'hBFF0000000000001; + z = 64'hBFF0000000000001; ans = 64'hBFF0000000000001; rn = 1; rz = 0; @@ -27929,19 +3111,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -27957,3912 +3139,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"364715\n"); + $fwrite(fp,"132923\n"); end - xrf = 64'h800C0454F11FDD89; - y = 64'h4018F1AF45350CCF; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h8036BC044C7B4FDB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"365329\n"); - end - xrf = 64'h0010000000000001; - y = 64'h3FF0000000000001; - zrf = 64'hC09FFFBFFFFFBFFF; - ans = 64'hC09FFFBFFFFFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"365943\n"); - end - xrf = 64'hBE4FC000007FFFFE; - y = 64'hC3D0080040000000; - zrf = 64'hC03FFFFFFDFFFDFF; - ans = 64'h422FCFE07F404000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"366557\n"); - end - xrf = 64'hBF80000000008000; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC02008000000003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"367171\n"); - end - xrf = 64'h0010000000000001; - y = 64'hBD0FFFFFD7FFFFFF; - zrf = 64'hC3D00080003FFFFF; - ans = 64'hC3D00080003FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"367785\n"); - end - xrf = 64'h7FDFFEFFFFFF7FFE; - y = 64'h4000000000000000; - zrf = 64'h002FFFFFE000007F; - ans = 64'h7FEFFEFFFFFF7FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"368399\n"); - end - xrf = 64'h0010000000000001; - y = 64'h3FCFFFFDFFFBFFFF; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"369013\n"); - end - xrf = 64'h3FFFFE000007FFFF; - y = 64'h41DFFFE000100000; - zrf = 64'hBFE507C600F1F12A; - ans = 64'h41EFFDE00202F731; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"369627\n"); - end - xrf = 64'h0010000000000001; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"370241\n"); - end - xrf = 64'hBCE00000001FFFFB; - y = 64'h400007FF7FFFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"370855\n"); - end - xrf = 64'h0010000000000001; - y = 64'h4010000000000000; - zrf = 64'h40A0008000000200; - ans = 64'h40A0008000000200; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"371469\n"); - end - xrf = 64'h3FDFF5989FAB38C7; - y = 64'hB810000400000002; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"372083\n"); - end - xrf = 64'hDE7FFFEFFFFFFFBF; - y = 64'h4010000000000001; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hDE9FFFEFFFFFFFC1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"372697\n"); - end - xrf = 64'h0010000000000001; - y = 64'h80001FFFF7FFFFFE; - zrf = 64'hC001FFFFFFFFFFDF; - ans = 64'hC001FFFFFFFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"373311\n"); - end - xrf = 64'hC010003FFFFFFFFF; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hC1FB6BC37B0AF313; - ans = 64'hC1FB6BC37D0AFB13; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"373925\n"); - end - xrf = 64'h0010000000000001; - y = 64'hB8BFFFF80000FFFE; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h3CAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"374539\n"); - end - xrf = 64'h38A8B771F85C15DA; - y = 64'hBFDFFFFEFFFFFFBE; - zrf = 64'h3E6FFFFFFC03FFFE; - ans = 64'h3E6FFFFFFC03FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"375153\n"); - end - xrf = 64'h0010000000000001; - y = 64'h4340000000000001; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"375767\n"); - end - xrf = 64'h4FCAAD2F5FC33B20; - y = 64'h376FF7EFFFFFFFFE; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"376381\n"); - end - xrf = 64'h0010000000000001; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hC007F2D5B3D5ED32; - ans = 64'hC007F2D5B3D5ED32; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"376995\n"); - end - xrf = 64'h402FFFFBFFFFFBFF; - y = 64'hC7E659F40C826256; - zrf = 64'hBFEC06F9894A7A32; - ans = 64'hC82659F14143DDFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"377609\n"); - end - xrf = 64'hBCAF5F38CB074578; - y = 64'h7FE0000000000000; - zrf = 64'hC000000000000000; - ans = 64'hFC9F5F38CB074578; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"378223\n"); - end - xrf = 64'h0010000000000001; - y = 64'hC01FEFFFFFFF8000; - zrf = 64'h3FB7FFFFFFFFFFDF; - ans = 64'h3FB7FFFFFFFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"378837\n"); - end - xrf = 64'h3DCD677997FE3E3B; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hFAC3698D88B4775C; - ans = 64'h7DCD677997FE3E27; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"379451\n"); - end - xrf = 64'h0010000000000001; - y = 64'h56600000FFFDFFFE; - zrf = 64'h3CA0000000000000; - ans = 64'h3CA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"380065\n"); - end - xrf = 64'hC5D0080000800000; - y = 64'hB930008001FFFFFF; - zrf = 64'h43FFFFFFFFFFFF83; - ans = 64'h43FFFFFFFFFFFF83; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"380679\n"); - end - xrf = 64'h0010000000000001; - y = 64'h7FF0000000000000; - zrf = 64'hBFD0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"381293\n"); - end - xrf = 64'hBFC4EC65823F040A; - y = 64'h8DDFFFFFE0000400; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"381907\n"); - end - xrf = 64'h0010000000000001; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'hFFD07FF7FFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"382521\n"); - end - xrf = 64'h41BFFFFFF7FFF000; - y = 64'hC19E0AA274921E95; - zrf = 64'hC2CFFFFFFE001FFE; - ans = 64'hC36E12A26D0EE6FB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"383135\n"); - end - xrf = 64'hBCF1FFFFFFFFFEFE; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'hBFF0000000000001; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"383749\n"); - end - xrf = 64'h0010000000000001; - y = 64'hFFF205635E5BC7FC; - zrf = 64'hC7F200000003FFFF; - ans = 64'hFFFA05635E5BC7FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"384363\n"); - end - xrf = 64'h41CFFFFFFFEFFFE0; - y = 64'h8000000000000001; - zrf = 64'h41D1CDB29820C684; - ans = 64'h41D1CDB29820C684; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"384977\n"); - end - xrf = 64'h0010000000000001; - y = 64'hC80FFFF000400000; - zrf = 64'h0010000000000001; - ans = 64'h882FFFF000400002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"385591\n"); - end - xrf = 64'h41DFFFFBFFFFFFFF; - y = 64'hFEB3FFFFFFFFFFFF; - zrf = 64'h39BEFFFFFFF80000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"386205\n"); - end - xrf = 64'h0010000000000001; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"386819\n"); - end - xrf = 64'h43D4347C467523C5; - y = 64'h3CF0003FFFFFFFF7; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h4350000000001434; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"387433\n"); - end - xrf = 64'h0010000000000001; - y = 64'h8010000000000001; - zrf = 64'hC1D0E21DDC57C6F2; - ans = 64'hC1D0E21DDC57C6F2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"388047\n"); - end - xrf = 64'h3FAEC83956AF6BDA; - y = 64'h47EFFFFFFFF007FF; - zrf = 64'h2DBBA7D5393B1408; - ans = 64'h47AEC83956A00F6E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"388661\n"); - end - xrf = 64'hBFB543040DD1458A; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"389275\n"); - end - xrf = 64'h0010000000000001; - y = 64'hD5687D0C01D0A5C0; - zrf = 64'hC37FFFFFFDFFFDFE; - ans = 64'hC37FFFFFFDFFFDFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"389889\n"); - end - xrf = 64'hC03DB75E6B3453F3; - y = 64'hBCA0000000000000; - zrf = 64'hC56FFBFFEFFFFFFE; - ans = 64'hC56FFBFFEFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"390503\n"); - end - xrf = 64'h0010000000000001; - y = 64'h437FFFFF3FFFFFFF; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h039FFFFF40000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"391117\n"); - end - xrf = 64'h42170719F6674DF0; - y = 64'hBFCFF800000003FF; - zrf = 64'h41D0007F7FFFFFFF; - ans = 64'hC1F301384FE9B6FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"391731\n"); - end - xrf = 64'h0010000000000001; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h8020000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"392345\n"); - end - xrf = 64'h3FBFFFFE01FFFFFF; - y = 64'hBEBFFFFFFFF00800; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h401FFFFFF00000FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"392959\n"); - end - xrf = 64'h0010000000000001; - y = 64'hBFD0000000000000; - zrf = 64'h41E0008000000002; - ans = 64'h41E0008000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"393573\n"); - end - xrf = 64'h3FB11BFBA3DA9D75; - y = 64'hCF2FFFFF81FFFFFF; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hCEF11BFB607C6E9F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"394187\n"); - end - xrf = 64'hC730000400000003; - y = 64'hBFD0000000000001; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'h4710000400000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"394801\n"); - end - xrf = 64'h0010000000000001; - y = 64'h414FF0000000001F; - zrf = 64'h3FFBFFFFFFFFFEFE; - ans = 64'h3FFBFFFFFFFFFEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"395415\n"); - end - xrf = 64'h41D00FFFFFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h3FF6FFBCCC05FB7F; - ans = 64'hC1C00FFFFF480218; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"396029\n"); - end - xrf = 64'h0010000000000001; - y = 64'h7FE40000003FFFFE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"396643\n"); - end - xrf = 64'h5B31FBFFFFFFFFFE; - y = 64'h401001FFFFFFFFF6; - zrf = 64'h1150000FFFF7FFFE; - ans = 64'h5B51FE3F7FFFFFF3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"397257\n"); - end - xrf = 64'h0010000000000001; - y = 64'hBFE0000000000001; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h8017FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"397871\n"); - end - xrf = 64'h41DFFFDF7FFFFFFF; - y = 64'hC6B0001007FFFFFE; - zrf = 64'h4010000000000000; - ans = 64'hC89FFFFF8FDF6FBB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"398485\n"); - end - xrf = 64'h0010000000000001; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hCE2FFFEFFFFFFC00; - ans = 64'hCE2FFFEFFFFFFC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"399099\n"); - end - xrf = 64'hBFFFFFFFAFFFFFFE; - y = 64'hC340400000FFFFFF; - zrf = 64'hBF0FFFBFFFF80000; - ans = 64'h43503FFFD85FFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"399713\n"); - end - xrf = 64'h3FCB24DCD9C1D121; - y = 64'hBFF0000000000000; - zrf = 64'hBFD0000000000000; - ans = 64'hBFDD926E6CE0E890; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"400327\n"); - end - xrf = 64'h0010000000000001; - y = 64'hC1CFFF7FFFFFFE00; - zrf = 64'h3FE00000003FFC00; - ans = 64'h3FE00000003FFC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"400941\n"); - end - xrf = 64'hBE1000003FFFFFBF; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'hC34FF000003FFFFE; - ans = 64'hC34FF000003FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"401555\n"); - end - xrf = 64'h0010000000000001; - y = 64'h657003FFFFFFFC00; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"402169\n"); - end - xrf = 64'h000B911E4CBDACCE; - y = 64'h39804000000003FF; - zrf = 64'h00139BDEF80EC19D; - ans = 64'h00139BDEF80EC19D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"402783\n"); - end - xrf = 64'h0010000000000001; - y = 64'hC000000000000000; - zrf = 64'h8000000000000000; - ans = 64'h8020000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"403397\n"); - end - xrf = 64'h402FFFFFFC003FFE; - y = 64'hFFDF800010000000; - zrf = 64'h4000000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"404011\n"); - end - xrf = 64'h0010000000000001; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h3FC0003FFFFF7FFF; - ans = 64'h3FC0003FFFFF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"404625\n"); - end - xrf = 64'hFFE00000000010FE; - y = 64'h94432AB61CDBA523; - zrf = 64'h3E3BFFFFFFFFBFFE; - ans = 64'h54332AB61CDBB97E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"405239\n"); - end - xrf = 64'h178FFFFFFFEFDFFE; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"405853\n"); - end - xrf = 64'h0010000000000001; - y = 64'h41EFFFFFFFFFFF7F; - zrf = 64'h47FFFFFFFFFFFFC1; - ans = 64'h47FFFFFFFFFFFFC1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"406467\n"); - end - xrf = 64'h3CAFFFDBFFFFFFFF; - y = 64'hC010000000000001; - zrf = 64'h41D000FC00000000; - ans = 64'h41D000FC00000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"407081\n"); - end - xrf = 64'h0010000000000001; - y = 64'hB7F989C602E18CB6; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"407695\n"); - end - xrf = 64'hC0068C39C8421A45; - y = 64'h3EF00000207FFFFE; - zrf = 64'hBFD000000003FFBF; - ans = 64'hBFD000B461D3B036; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"408309\n"); - end - xrf = 64'h0010000000000001; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"408923\n"); - end - xrf = 64'hC1DFFF6FFFFFFFFF; - y = 64'hBB80000000000102; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h40000000000007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"409537\n"); - end - xrf = 64'h0010000000000001; - y = 64'hC340000000000001; - zrf = 64'h3FCFFFFEFFFFDFFE; - ans = 64'h3FCFFFFEFFFFDFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"410151\n"); - end - xrf = 64'h3C7FFFFFF8008000; - y = 64'hC806EE1414AFC71A; - zrf = 64'h3D10D39F6CFAD054; - ans = 64'hC496EE140EF49DCD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"410765\n"); - end - xrf = 64'h3E212A83DE6986F5; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'hC1812A83DE6986F4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"411379\n"); - end - xrf = 64'h0010000000000001; - y = 64'h3FE00000201FFFFF; - zrf = 64'h3FEFFFFFFF8000FF; - ans = 64'h3FEFFFFFFF8000FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"411993\n"); - end - xrf = 64'h4807FFFDFFFFFFFE; - y = 64'hFFE0000000000000; - zrf = 64'h45B00000100003FF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"412607\n"); - end - xrf = 64'h0010000000000001; - y = 64'hC1DFFFFFC00FFFFF; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"413221\n"); - end - xrf = 64'h4C90080000007FFF; - y = 64'h4180007DFFFFFFFF; - zrf = 64'hB7FFFCFFFFFFFFFF; - ans = 64'h4E20087E3F008002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"413835\n"); - end - xrf = 64'h0010000000000001; + x = 64'h429FFFDFFFFEFFFE; y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"414449\n"); - end - xrf = 64'hC67D0752856A715F; - y = 64'hB2E000000BFFFFFF; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h3FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"415063\n"); - end - xrf = 64'h0010000000000001; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'hD5900001FFFF7FFF; - ans = 64'hD5900001FFFF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"415677\n"); - end - xrf = 64'h401FFF8003FFFFFF; - y = 64'hFFEFFFFFFFFDFFFF; - zrf = 64'hBFBFF7FFFFFFEFFF; + z = 64'h402FE0000000007F; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -31877,19 +3158,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -31905,12 +3186,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"416291\n"); + $fwrite(fp,"134937\n"); end - xrf = 64'h383FE00000001FFF; - y = 64'hFFF0000000000001; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hFFF8000000000001; + x = 64'hBF3000000DFFFFFF; + y = 64'hBF8000040007FFFE; + z = 64'h0197F2FDF4257279; + ans = 64'h3EC000040E08037D; rn = 1; rz = 0; rm = 0; @@ -31924,19 +3205,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -31952,58 +3233,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"416905\n"); + $fwrite(fp,"136951\n"); end - xrf = 64'h0010000000000001; - y = 64'h403FFFFBFFFFE000; - zrf = 64'hCC7DFFFFFFFFBFFE; - ans = 64'hCC7DFFFFFFFFBFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"417519\n"); - end - xrf = 64'h47EFF87FFFFFFFFE; + x = 64'h0000000000000001; y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h00080001FFFFFFFE; + z = 64'h4340000000000000; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -32018,19 +3252,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -32046,106 +3280,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"418133\n"); + $fwrite(fp,"138965\n"); end - xrf = 64'h0010000000000001; - y = 64'h3FD43FFFFFFFFFFF; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"418747\n"); - end - xrf = 64'h41E1FFFFFFFFFFEF; - y = 64'hF3303EFFFFFFFFFF; - zrf = 64'h46BFFFFFFF001FFF; - ans = 64'hF52246DFFFFFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"419361\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; + x = 64'hC005937FE4462628; y = 64'h0000000000000001; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; + z = 64'hC24FF9FFFFFFFFFE; + ans = 64'hC24FF9FFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -32159,19 +3299,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -32187,12 +3327,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"419975\n"); + $fwrite(fp,"140979\n"); end - xrf = 64'h3FD007FFFF7FFFFE; - y = 64'h3FFFFFFFFBFFFEFF; - zrf = 64'h3FE0000000000000; - ans = 64'h3FF003FFFEBF7FBF; + x = 64'h802F9AD608A7A076; + y = 64'hFFF0000001FFF7FF; + z = 64'h3BBFFFFFFFBFFFBE; + ans = 64'hFFF8000001FFF7FF; rn = 1; rz = 0; rm = 0; @@ -32206,19 +3346,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -32234,200 +3374,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"420589\n"); + $fwrite(fp,"142993\n"); end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h396C5680AC81324C; - ans = 64'h396C5680AC81324C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"421203\n"); - end - xrf = 64'hBFF0000000004006; - y = 64'h3800002000000006; - zrf = 64'hA7700FF000000000; - ans = 64'hB80000200000400D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"421817\n"); - end - xrf = 64'hA2EFFFFFFFF7FC00; - y = 64'h0010000000000000; - zrf = 64'h8000000000000000; - ans = 64'h8000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"422431\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'hDE40000000140000; - zrf = 64'h3E17FFFEFFFFFFFF; - ans = 64'h3E17FFFEFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"423045\n"); - end - xrf = 64'hBFF000007FEFFFFF; + x = 64'h000FFFFFFFFFFFFF; y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hBF7000FFBFFFFFFF; - ans = 64'hBF7000FFBFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -32441,19 +3393,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -32469,12 +3421,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"423659\n"); + $fwrite(fp,"145007\n"); end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h5FF000000000FF80; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; + x = 64'h423FDFC000000000; + y = 64'h3CA0000000000001; + z = 64'hC00584E2101BE3EF; + ans = 64'hC00584DA182BE3EF; rn = 1; rz = 0; rm = 0; @@ -32488,19 +3440,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -32516,12 +3468,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"424273\n"); + $fwrite(fp,"147021\n"); end - xrf = 64'h37F2018CDBC5E6EC; - y = 64'h3FD010007FFFFFFF; - zrf = 64'h3FDF87FFFFFFFFFF; - ans = 64'h3FDF87FFFFFFFFFF; + x = 64'hC03C54BD6921B05D; + y = 64'hC02FE007FFFFFFFF; + z = 64'hC0020B6D2412FDF2; + ans = 64'h407C1458E69FC2F8; rn = 1; rz = 0; rm = 0; @@ -32535,19 +3487,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -32563,11 +3515,857 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"424887\n"); + $fwrite(fp,"149035\n"); end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h3CA0000000000000; - zrf = 64'h4340000000000000; + x = 64'h000FFFFFFFFFFFFF; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"151049\n"); + end + x = 64'h375FE20000000000; + y = 64'h3FE0000000000001; + z = 64'hB46FFFFFFFFE0010; + ans = 64'h374FE1FFFFFFFF82; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"153063\n"); + end + x = 64'h403FFFFFE001FFFF; + y = 64'h3E5DAA9BEBA734CA; + z = 64'h4023FE0E11BE1E1E; + ans = 64'h4023FE0E2F68B9EC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"155077\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"157091\n"); + end + x = 64'h40E200000000003F; + y = 64'h4000000000000000; + z = 64'h41CFFFFFFFFFFDFE; + ans = 64'h41D00047FFFFFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"159105\n"); + end + x = 64'h3FDFFE0000001FFF; + y = 64'hC7EF000000000020; + z = 64'h41DFFFFFFFFFBEFF; + ans = 64'hC7DEFE1000001F1F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"161119\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h4010000000000001; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"163133\n"); + end + x = 64'h47EC49A3B6FE1E05; + y = 64'h4340000000000000; + z = 64'hC7F00001FFFF7FFF; + ans = 64'h4B3C49A3B6FE1E04; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"165147\n"); + end + x = 64'hBA5BFFFFFFFBFFFF; + y = 64'hC3EFF8F4A38946A4; + z = 64'hC03FFFFFBFFFC000; + ans = 64'hC03FFFFFBF8FD8A8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"167161\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h7FE0000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"169175\n"); + end + x = 64'h3FBFFFFFFFFFFFFA; + y = 64'h7FF0000000000000; + z = 64'h3801FFFFEFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"171189\n"); + end + x = 64'h50AAFE7C26407D06; + y = 64'h3FFDFFF7FFFFFFFF; + z = 64'h0E058C435455CC58; + ans = 64'h50B94E8DA43D6BA5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"173203\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'h8000000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"175217\n"); + end + x = 64'h43C001FFFFFFFDFF; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hC1C000007E000000; + ans = 64'hC1C000007E000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"177231\n"); + end + x = 64'h43D0000000004200; + y = 64'hFFDFFFF800000020; + z = 64'hC3EFFFFFFE7FFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"179245\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hBCA0000000000000; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"181259\n"); + end + x = 64'h3FFFFFFFFFEFBFFF; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h371FFDFFFBFFFFFF; + ans = 64'hBCBFFFFFFFEFBFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"183273\n"); + end + x = 64'h3FCFFFFFFFF10000; + y = 64'h3E9FFCFFFFFFFFFE; + z = 64'h37FFFFFFFFF001FF; + ans = 64'h3E7FFCFFFFF10166; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"185287\n"); + end + x = 64'h000FFFFFFFFFFFFF; + y = 64'hBFE0000000000000; + z = 64'h4340000000000000; ans = 64'h4340000000000000; rn = 1; rz = 0; @@ -32582,19 +4380,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -32610,12 +4408,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"425501\n"); + $fwrite(fp,"187301\n"); end - xrf = 64'h434040000000003E; - y = 64'hB81FFFFFFF7FFFFF; - zrf = 64'h3FD0000000000001; - ans = 64'h3FD0000000000001; + x = 64'hC1D8003FFFFFFFFF; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hB4200100007FFFFF; + ans = 64'h41D8003FFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -32629,19 +4427,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -32657,12 +4455,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"426115\n"); + $fwrite(fp,"189315\n"); end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h3CA0000000000001; - zrf = 64'h402FFFFFFEFFFF7F; - ans = 64'h402FFFFFFEFFFF7F; + x = 64'h43F08000003FFFFF; + y = 64'h43F0000000010007; + z = 64'h3FD000008000003F; + ans = 64'h47F0800000410806; rn = 1; rz = 0; rm = 0; @@ -32676,19 +4474,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -32704,12 +4502,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"426729\n"); + $fwrite(fp,"191329\n"); end - xrf = 64'hC3E001FFFFFBFFFF; - y = 64'hBFCFFFFC003FFFFE; - zrf = 64'h3FD000007FFFF800; - ans = 64'h43C001FDFFDC03FE; + x = 64'h000FFFFFFFFFFFFF; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -32723,19 +4521,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -32751,12 +4549,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"427343\n"); + $fwrite(fp,"193343\n"); end - xrf = 64'hB7F00001FEFFFFFE; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; + x = 64'hC42DB91340AF93D0; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h6A0000000000FF7F; + ans = 64'h6A0000000000FF7F; rn = 1; rz = 0; rm = 0; @@ -32770,19 +4568,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -32798,12 +4596,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"427957\n"); + $fwrite(fp,"195357\n"); end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h401FFFFBFFFFFFFE; - zrf = 64'h7FEDF7FFFFFFFFFE; - ans = 64'h7FEDF7FFFFFFFFFE; + x = 64'h4FC00020003FFFFF; + y = 64'h0020000002003FFF; + z = 64'h57B00000000FC000; + ans = 64'h57B00000000FC000; rn = 1; rz = 0; rm = 0; @@ -32817,19 +4615,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -32845,12 +4643,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"428571\n"); + $fwrite(fp,"197371\n"); end - xrf = 64'hB97000010000FFFF; - y = 64'h3FD0000000000001; - zrf = 64'hCDABA05ECB7D8187; - ans = 64'hCDABA05ECB7D8187; + x = 64'h000FFFFFFFFFFFFF; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -32864,19 +4662,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -32892,998 +4690,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"429185\n"); + $fwrite(fp,"199385\n"); end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h800FFFFBFC000000; - zrf = 64'hC000000000000001; - ans = 64'hC000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"429799\n"); - end - xrf = 64'hBFDC8AD94D9D9EA7; - y = 64'hBF1FFFFFDFFF0000; - zrf = 64'hC1E04000001FFFFE; - ans = 64'hC1E04000001FFF8C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"430413\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h4010000000000001; - ans = 64'h4010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"431027\n"); - end - xrf = 64'h403EE56F7508D6C4; - y = 64'h3E2FFFBFFFFFFF7F; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3E7EE531AB29EC36; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"431641\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h3FE0000000000000; - zrf = 64'h410F7FFFFFFFFBFF; - ans = 64'h410F7FFFFFFFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"432255\n"); - end - xrf = 64'hBFFFFFFF9FFFFFFF; - y = 64'h3FC000BFFFFFFFFE; - zrf = 64'h47FE4FE7FC5CA94B; - ans = 64'h47FE4FE7FC5CA94B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"432869\n"); - end - xrf = 64'h3EF00000000007FD; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"433483\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h8000ADABC1083601; - zrf = 64'h7A500003FFFFFFDF; - ans = 64'h7A500003FFFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"434097\n"); - end - xrf = 64'hC3C100000003FFFF; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h80001FFFFFFFFEFF; - ans = 64'hC3C100000003FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"434711\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'hBD5000000FDFFFFE; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"435325\n"); - end - xrf = 64'hC14EFFFFFFFFFFF0; - y = 64'hBB7F00000007FFFE; - zrf = 64'h401FFFEFFFFFFFF6; - ans = 64'h401FFFEFFFFFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"435939\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h400FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"436553\n"); - end - xrf = 64'hBD8FE00020000000; - y = 64'h43FBD1AA550D93D7; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'hC19BB5D8C68A3098; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"437167\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h37F3FFFFFBFFFFFE; - ans = 64'h37F3FFFFFBFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"437781\n"); - end - xrf = 64'h7FEE640EDD7D325B; - y = 64'hBF9FFEFFFFF80000; - zrf = 64'hC6FFC00000000000; - ans = 64'hFF9E631BBCFEAD6E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"438395\n"); - end - xrf = 64'hC00000000FFFDFFF; - y = 64'h4000000000000001; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"439009\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'hC7FFFFFF00000004; - zrf = 64'h3F771D032C61EC36; - ans = 64'h3F771D032C61EC36; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"439623\n"); - end - xrf = 64'h41E76CC19771603B; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hCD70020000800000; - ans = 64'hCD70020000800000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"440237\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h3FEDFFFFFFFFFFF0; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hBFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"440851\n"); - end - xrf = 64'h001FFFFFFFFFFF02; - y = 64'h39FEC6BF7D1B70B5; - zrf = 64'h9DC000000001FFBE; - ans = 64'h9DC000000001FFBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"441465\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h4010000000000001; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h3FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"442079\n"); - end - xrf = 64'h7FE00000000007F7; - y = 64'hCBDFFFFFFFFFFFFF; - zrf = 64'h0010000000000000; + x = 64'h7FE0400000800000; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h43FFFFFDFFFFFFBF; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -33898,19 +4709,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -33926,12 +4737,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"442693\n"); + $fwrite(fp,"201399\n"); end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h41CFFFFFFFF07FFF; - ans = 64'h41CFFFFFFFF07FFF; + x = 64'h3F8CD1CDC67650EA; + y = 64'hC017EFFFFFFFFFFE; + z = 64'h43CFFDEFFFFFFFFF; + ans = 64'h43CFFDEFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -33945,19 +4756,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -33973,12 +4784,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"443307\n"); + $fwrite(fp,"203413\n"); end - xrf = 64'h40B318ECB7EB7D19; - y = 64'h3FF51305D82EA9EE; - zrf = 64'hC3FFBFFFFFFFFFBF; - ans = 64'hC3FFBFFFFFFFFFBD; + x = 64'h000FFFFFFFFFFFFF; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'hC007FFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -33992,19 +4803,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -34020,12 +4831,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"443921\n"); + $fwrite(fp,"205427\n"); end - xrf = 64'h3FD65C4920561A4B; - y = 64'h4340000000000000; - zrf = 64'h4340000000000000; - ans = 64'h4345971248158693; + x = 64'h924ADC0D0C7D8041; + y = 64'hFFF0000000000001; + z = 64'h3FBFFEFFFFFEFFFE; + ans = 64'hFFF8000000000001; rn = 1; rz = 0; rm = 0; @@ -34039,19 +4850,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -34067,12 +4878,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"444535\n"); + $fwrite(fp,"207441\n"); end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'hC002673D3605EDFC; - zrf = 64'hFFF0001000FFFFFF; - ans = 64'hFFF8001000FFFFFF; + x = 64'h3FBFFFFFFFFC0003; + y = 64'h43F0200000004000; + z = 64'h3FC9E8FB1845E2EC; + ans = 64'h43C01FFFFFFE3C02; rn = 1; rz = 0; rm = 0; @@ -34086,19 +4897,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -34114,12 +4925,576 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"445149\n"); + $fwrite(fp,"209455\n"); end - xrf = 64'h43C000020000003E; + x = 64'h000FFFFFFFFFFFFE; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"211469\n"); + end + x = 64'hC041C7DCE2709A19; + y = 64'h0010000000000001; + z = 64'h3FCF7FFFFFF00000; + ans = 64'h3FCF7FFFFFF00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"213483\n"); + end + x = 64'h380C374E4A521601; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h43CFFF80001FFFFF; + ans = 64'h43CFFF80001FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"215497\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"217511\n"); + end + x = 64'h7FF1C6B1098FF7F7; + y = 64'h3FD0000000000001; + z = 64'hC80FFC007FFFFFFE; + ans = 64'h7FF9C6B1098FF7F7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"219525\n"); + end + x = 64'hC01000000FFFFFFE; + y = 64'hF6EFFFFFF000FFFF; + z = 64'h41EFFE0080000000; + ans = 64'h7710000008007FF6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"221539\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"223553\n"); + end + x = 64'h43DC9799AEAC7B3A; + y = 64'h3FF0000000000000; + z = 64'hC0FFF7FFFFFFFFFF; + ans = 64'h43DC9799AEAC7ABA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"225567\n"); + end + x = 64'h3FDE39086553EEEC; + y = 64'hDF9221710B73E617; + z = 64'h3EEE6111637E2863; + ans = 64'hDF811FAA4DDE6BEC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"227581\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h4000000000000001; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"229595\n"); + end + x = 64'h3FFFFF7FFDFFFFFF; + y = 64'h4010000000000000; + z = 64'h47748A41CB17831D; + ans = 64'h47748A41CB17831D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"231609\n"); + end + x = 64'hC0D0FFFFFFFFFE00; + y = 64'h3F3FFFF800800000; + z = 64'h0018661007BF7450; + ans = 64'hC020FFFBC043FE00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"233623\n"); + end + x = 64'h000FFFFFFFFFFFFE; y = 64'h4340000000000001; - zrf = 64'hC00000003FFFFFBF; - ans = 64'h471000020000003F; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; rn = 1; rz = 0; rm = 0; @@ -34133,19 +5508,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -34161,12 +5536,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"445763\n"); + $fwrite(fp,"235637\n"); end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'hB7EFFFFFFFFFFF80; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE0000000000000; + x = 64'h37EFFFFFFC800000; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hC1C623C26A784CB7; + ans = 64'hC1C623C26A784CB7; rn = 1; rz = 0; rm = 0; @@ -34180,19 +5555,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -34208,12 +5583,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"446377\n"); + $fwrite(fp,"237651\n"); end - xrf = 64'h42DFFFFFFFE7FFFF; - y = 64'h37ED7BB22AE6852A; - zrf = 64'hBFCFFFFFFFFFFFEF; - ans = 64'hBFCFFFFFFFFFFFEF; + x = 64'h40A20007FFFFFFFF; + y = 64'h41DFFFEFFFFFFFFD; + z = 64'h5123A0479A820274; + ans = 64'h5123A0479A820274; rn = 1; rz = 0; rm = 0; @@ -34227,19 +5602,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -34255,11 +5630,4805 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"446991\n"); + $fwrite(fp,"239665\n"); end - xrf = 64'h001FFFFFFFFFFFFF; + x = 64'h000FFFFFFFFFFFFE; + y = 64'h7FF0000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"241679\n"); + end + x = 64'h3C0FFEFFFDFFFFFF; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h40775445C2C8E6E5; + 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,"243693\n"); + end + x = 64'hBCAFFC0000000FFE; + y = 64'hC0100000001FFFFB; + z = 64'hBFCFFFF7FFFFBFFE; + ans = 64'hBFCFFFF7FFFFBFDE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"245707\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'h8010000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"247721\n"); + end + x = 64'h801FFEFFFFFFEFFE; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hC06000007FBFFFFE; + ans = 64'hC06000007FBFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"249735\n"); + end + x = 64'h3CA80000000000FE; + y = 64'h8017FB4D2CCAA271; + z = 64'h3F6000000010000F; + ans = 64'h3F6000000010000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"251749\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hBFD0000000000000; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"253763\n"); + end + x = 64'h403000000000080E; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hC05DFFF800000000; + ans = 64'hC05FFFF800000102; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"255777\n"); + end + x = 64'h3CA000000FFFF800; + y = 64'h243EFFDFFFFFFFFF; + z = 64'hBEB03FFFFFBFFFFE; + ans = 64'hBEB03FFFFFBFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"257791\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"259805\n"); + end + x = 64'h412007FFFEFFFFFF; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h4012000040000000; + ans = 64'hC13007FB7EFFEFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"261819\n"); + end + x = 64'h3FC0000003F7FFFE; + y = 64'h2C00FF7FFFFFFFFF; + z = 64'hBCBFFFFFFFFE7FFF; + ans = 64'hBCBFFFFFFFFE7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"263833\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"265847\n"); + end + x = 64'h47F0000800001FFF; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hB81FDFFFFFFFEFFE; + ans = 64'hC820000800001FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"267861\n"); + end + x = 64'h3FD0000FFFF7FFFE; + y = 64'h308FFFFFFBFFFFFD; + z = 64'h40000000003FFFFC; + ans = 64'h40000000003FFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"269875\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"271889\n"); + end + x = 64'h41CFFFFFF0003FFF; + y = 64'hFFE0000000000001; + z = 64'h409FFF0003FFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"273903\n"); + end + x = 64'hB8092EC54A99590C; + y = 64'h3D9ED2D3EF3AB013; + z = 64'h3FE00001FFFFFBFF; + ans = 64'h3FE00001FFFFFBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"275917\n"); + end + x = 64'h000FFFFFFFFFFFFE; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"277931\n"); + end + x = 64'hFFDF0195428D1378; + y = 64'h0000000000000001; + z = 64'hFFE0000500000000; + ans = 64'hFFE0000500000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"279945\n"); + end + x = 64'hBFE200000000FFFE; + y = 64'h41FD6E4653630B63; + z = 64'h480FFFF008000000; + ans = 64'h480FFFF008000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"281959\n"); + end + x = 64'h0010000000000000; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"283973\n"); + end + x = 64'h3CA5FFFFFFFFFFFF; + y = 64'h3CA0000000000000; + z = 64'h3FDFFE0000007FFE; + ans = 64'h3FDFFE0000007FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"285987\n"); + end + x = 64'hA4C1CB8F4C4A2248; + y = 64'h3F6DFFFDFFFFFFFF; + z = 64'h43CFFFFFFFFFF001; + ans = 64'h43CFFFFFFFFFF001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"288001\n"); + end + x = 64'h0010000000000000; + y = 64'h3FD0000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"290015\n"); + end + x = 64'hC7EFF7FFFDFFFFFF; + y = 64'h3FE0000000000000; + z = 64'h45BFFFFFF7FFFE00; + ans = 64'hC7DFF7FFFDF7FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"292029\n"); + end + x = 64'h3FC0DC6ED2EAFE1A; + y = 64'h9D30004000000080; + z = 64'h402FFFFF7FFC0000; + ans = 64'h402FFFFF7FFC0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"294043\n"); + end + x = 64'h0010000000000000; + y = 64'h3FF0000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"296057\n"); + end + x = 64'hFFD0001FFFEFFFFF; + y = 64'h4000000000000000; + z = 64'hB9DFFFFFFBFFF800; + ans = 64'hFFE0001FFFEFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"298071\n"); + end + x = 64'h3FEFFF7FFFFEFFFF; + y = 64'h41E0001003FFFFFF; + z = 64'hC074811E0051B61D; + ans = 64'h41DFFF9FB57A67FB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"300085\n"); + end + x = 64'h0010000000000000; + y = 64'h4010000000000001; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"302099\n"); + end + x = 64'hBFDFFFFFB0000000; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h4000000800003FFF; + ans = 64'hBFFFFFEF5FFF7FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"304113\n"); + end + x = 64'h403002000003FFFF; + y = 64'h43C00FFBFFFFFFFF; + z = 64'h3FB000401FFFFFFE; + ans = 64'h440011FDFF8403FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"306127\n"); + end + x = 64'h0010000000000000; y = 64'h7FE0000000000000; - zrf = 64'h3FF0000000000000; + z = 64'hC340000000000000; + ans = 64'hC33FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"308141\n"); + end + x = 64'h402FBFFFFFFFBFFF; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h47F7B2028F6F437D; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"310155\n"); + end + x = 64'hC02FFFFFFFBFFFFF; + y = 64'hB39FFFFFFFFFF808; + z = 64'h43FFFFF000002000; + ans = 64'h43FFFFF000002000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"312169\n"); + end + x = 64'h0010000000000000; + y = 64'h8000000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"314183\n"); + end + x = 64'hC1DBFFFFFFFF7FFF; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h37FFFDFFFFFFFF00; + ans = 64'h37FFFDFFFFFFFF00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"316197\n"); + end + x = 64'hC3FA269DD2690536; + y = 64'hC80200007FFFFFFE; + z = 64'h3F1000FFFFBFFFFF; + ans = 64'h4C0D6B725DEB146D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"318211\n"); + end + x = 64'h0010000000000000; + y = 64'hBCA0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"320225\n"); + end + x = 64'hC09000003FFFBFFF; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hC02FFFFFFFFE01FF; + ans = 64'hC02FFFFFFFFE017F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"322239\n"); + end + x = 64'h000FFFEFFFFFFFEF; + y = 64'h3CD08A79FF518287; + z = 64'h41B00000002000FF; + ans = 64'h41B00000002000FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"324253\n"); + end + x = 64'h0010000000000000; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"326267\n"); + end + x = 64'h5120000080000FFF; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hBFBC00000000003F; + ans = 64'hD120000080000FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"328281\n"); + end + x = 64'hBA50000002001000; + y = 64'hC790000000000407; + z = 64'hB150002003FFFFFF; + ans = 64'h41F0000002001407; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"330295\n"); + end + x = 64'h0010000000000000; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"332309\n"); + end + x = 64'hBEEF802000000000; + y = 64'hC000000000000001; + z = 64'h4000000000DFFFFF; + ans = 64'h4000000FC0EFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"334323\n"); + end + x = 64'hBDFFFFF8000000FE; + y = 64'hBA37EF95F9E7FCB2; + z = 64'hBA2FC000007FFFFF; + ans = 64'hBA2FC000002041BF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"336337\n"); + end + x = 64'h0010000000000000; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"338351\n"); + end + x = 64'hBFE7DA39E756FAB8; + y = 64'hC340000000000001; + z = 64'h41D87200E15761BA; + ans = 64'h4337DA3A491EFE3F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"340365\n"); + end + x = 64'h39EFFFF000000040; + y = 64'hBFA0000000020FFF; + z = 64'hBD117042903CB8AA; + ans = 64'hBD117042903CB8AA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"342379\n"); + end + x = 64'h0010000000000000; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hC00FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"344393\n"); + end + x = 64'hB2AFFE2000000000; + y = 64'hFFF0000000000001; + z = 64'h000FFEFFFFE00000; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"346407\n"); + end + x = 64'hBF4FF8000003FFFF; + y = 64'h400FC000000001FF; + z = 64'hBFD1000000040000; + ans = 64'hBFD13F70200407F4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"348421\n"); + end + x = 64'h0010000000000001; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"350435\n"); + end + x = 64'h417FFF7FFFFFFF00; + y = 64'h0010000000000000; + z = 64'h37FA53BB21817EC2; + ans = 64'h37FA53BB21817EC2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"352449\n"); + end + x = 64'h480FFC0100000000; + y = 64'h46F0000001007FFF; + z = 64'hC010000000000000; + ans = 64'h4F0FFC010200BFEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"354463\n"); + end + x = 64'h0010000000000001; + y = 64'h3CA0000000000001; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"356477\n"); + end + x = 64'h43FAE7911860836B; + y = 64'h3FD0000000000000; + z = 64'h25D0478B318DBCB2; + ans = 64'h43DAE7911860836B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"358491\n"); + end + x = 64'hC28FF7EFFFFFFFFF; + y = 64'hFFE0000000001EFE; + z = 64'hC5E000000FFFFFBF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"360505\n"); + end + x = 64'h0010000000000001; + y = 64'h3FE0000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"362519\n"); + end + x = 64'hBF3FE0003FFFFFFE; + y = 64'h3FF0000000000000; + z = 64'hBD83FFFFFFFFFFFE; + ans = 64'hBF3FE000427FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"364533\n"); + end + x = 64'h3FD00403FFFFFFFE; + y = 64'h25BFF00000100000; + z = 64'hBF6003FFFFFFFFFB; + ans = 64'hBF6003FFFFFFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"366547\n"); + end + x = 64'h0010000000000001; + y = 64'h4000000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"368561\n"); + end + x = 64'h38F986D8EF088441; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hB806D62A6ADF932D; + ans = 64'h391986CD83F34ED0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"370575\n"); + end + x = 64'h52CFFFEFFFFFFBFE; + y = 64'hC3DCF5E2283E4645; + z = 64'h3FDFFFC004000000; + ans = 64'hD6BCF5D3AD4D2E85; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"372589\n"); + end + x = 64'h0010000000000001; + y = 64'h4340000000000000; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"374603\n"); + end + x = 64'h3D50FFFFFFFFFBFF; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hC13FF000007FFFFF; + ans = 64'hC13FDF0000800003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"376617\n"); + end + x = 64'hFA10007FFFFFFF7E; + y = 64'h80025B95F6F2AE19; + z = 64'hC2B00000000403FF; + ans = 64'hC2B00000000403FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"378631\n"); + end + x = 64'h0010000000000001; + y = 64'h7FF0000000000000; + z = 64'h4340000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"380645\n"); + end + x = 64'h3800000800000003; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h4020AE1F9ECA9031; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"382659\n"); + end + x = 64'h2703A2471F27E3E3; + y = 64'hC03AEB1CF89CD9EB; + z = 64'h3FF007FFFFDFFFFF; + ans = 64'h3FF007FFFFDFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"384673\n"); + end + x = 64'h0010000000000001; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"386687\n"); + end + x = 64'h40000FEFFFFFFFFF; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h4D3FFFFFFFC00080; + ans = 64'h4D3FFFFFFFC00080; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"388701\n"); + end + x = 64'h43CCA7AE5B9D672B; + y = 64'hC803D86978A18D8C; + z = 64'h4020180000000000; + ans = 64'hCBE1C559D1897093; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"390715\n"); + end + x = 64'h0010000000000001; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"392729\n"); + end + x = 64'h7FD01003FFFFFFFF; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hBF8FFFFDBFFFFFFF; + ans = 64'hFFC01003FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"394743\n"); + end + x = 64'hC1C007FFFFFFFF7F; + y = 64'hC7EFFFFFFFFC1FFF; + z = 64'h47FFFFFFFF800001; + ans = 64'h49C0080000FE0E86; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"396757\n"); + end + x = 64'h0010000000000001; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"398771\n"); + end + x = 64'hC024ABDD47F0BA3B; + y = 64'hBFF0000000000001; + z = 64'h002000FFBFFFFFFF; + ans = 64'h4024ABDD47F0BA3C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"400785\n"); + end + x = 64'hB7F9E772425B7128; + y = 64'hBFAFFDC000000000; + z = 64'h380FFFFFFFFBFFFD; + ans = 64'h381067967FEF4B19; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"402799\n"); + end + x = 64'h0010000000000001; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"404813\n"); + end + x = 64'hC7E000000000002F; + y = 64'hC010000000000001; + z = 64'hE8CFFFFFFF00007F; + ans = 64'hE8CFFFFFFF00007F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"406827\n"); + end + x = 64'h42903FFFFFFFFFFE; + y = 64'h47E00000FEFFFFFF; + z = 64'hC03FFFFFFFFFEFF7; + ans = 64'h4A80400102FBFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"408841\n"); + end + x = 64'h0010000000000001; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"410855\n"); + end + x = 64'hBFD2000000FFFFFF; + y = 64'hFFE0000000000001; + z = 64'hC16FFFFFFFFF7FEF; + ans = 64'h7FC2000001000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"412869\n"); + end + x = 64'h34E0400000000002; + y = 64'hC071FFFE00000000; + z = 64'h47E0000000400200; + ans = 64'h47E0000000400200; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"414883\n"); + end + x = 64'h0010000000000001; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"416897\n"); + end + x = 64'hB3DFFFFFFFEFFE00; + y = 64'h0000000000000000; + z = 64'h401BDB831CE041E3; + ans = 64'h401BDB831CE041E3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"418911\n"); + end + x = 64'h43E000000007FFFA; + y = 64'hBFB41FCB52017EB1; + z = 64'hBFC0919E9745A592; + ans = 64'hC3A41FCB520B8E8F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"420925\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h0010000000000001; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"422939\n"); + end + x = 64'hBC59DD57D7AE3685; + y = 64'h3CA0000000000000; + z = 64'h40002001FFFFFFFE; + ans = 64'h40002001FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"424953\n"); + end + x = 64'h7FE000000007FFBE; + y = 64'hF8EFFFFFF7BFFFFF; + z = 64'h4004A9F4D740C561; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"426967\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h3FD0000000000001; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"428981\n"); + end + x = 64'h7FF0000800020000; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h3FCF9886FD508BAC; + ans = 64'h7FF8000800020000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"430995\n"); + end + x = 64'h80047FFFFFFFFFFF; + y = 64'h3FF0000001008000; + z = 64'h3FB5BEBC9BBB5778; + ans = 64'h3FB5BEBC9BBB5778; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"433009\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h3FF0000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"435023\n"); + end + x = 64'h40D000000000FFC0; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hBFF8001FFFFFFFFF; + ans = 64'h40DFFF9FFF81FF7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"437037\n"); + end + x = 64'h42A0400000FFFFFF; + y = 64'h3FB0007FEFFFFFFE; + z = 64'hC09F800000000400; + ans = 64'h42604081EFC407FC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"439051\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h4010000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"441065\n"); + end + x = 64'hB81FFFC000000020; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h0019444730A7E4F3; + ans = 64'hB84FFFC00000001E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"443079\n"); + end + x = 64'h402AA929B284BE76; + y = 64'hBFF0000004000010; + z = 64'h802FFFFFFFFFFEEF; + ans = 64'hC02AA929B92F08FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"445093\n"); + end + x = 64'h001FFFFFFFFFFFFF; + y = 64'h7FE0000000000000; + z = 64'h3FF0000000000001; ans = 64'h4014000000000000; rn = 1; rz = 0; @@ -34274,19 +10443,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -34302,5464 +10471,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"447605\n"); + $fwrite(fp,"447107\n"); end - xrf = 64'h802000003FFFFBFF; - y = 64'hC3CFFFFFFFFFFFD7; - zrf = 64'h0000000000000001; - ans = 64'h040000003FFFFBEA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"448219\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h7FE0000000000001; - zrf = 64'h43E3FFFF80000000; - ans = 64'h43E3FFFF80000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"448833\n"); - end - xrf = 64'hC3423795C42FF6F8; - y = 64'hC070043FFFFFFFFF; - zrf = 64'hBFDCEB966144812B; - ans = 64'h43C23C6C87F813B4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"449447\n"); - end - xrf = 64'h400FFFF87FFFFFFF; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h4010000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"450061\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h413C7FD643DAF76F; - zrf = 64'hC05D90A520010B43; - ans = 64'hC05D90A520010B43; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"450675\n"); - end - xrf = 64'h4220040000080000; - y = 64'h7FF0000000000000; - zrf = 64'hB7F2E64B75544CD9; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"451289\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h40E00000002FFFFE; - zrf = 64'hBFD0000000000001; - ans = 64'hBFD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"451903\n"); - end - xrf = 64'h37F00000000017FE; - y = 64'hBFDC9E6C8A133CA5; - zrf = 64'h39EEFFFFFFFFFFFF; - ans = 64'h39EEFFFFFFF1B0C9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"452517\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h3FE0000000000001; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"453131\n"); - end - xrf = 64'hC130000000007FDF; - y = 64'h3CABD2A0BF65E45F; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"453745\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h8000000000000000; - zrf = 64'hC1CFB2531402EC4E; - ans = 64'hC1CFB2531402EC4E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"454359\n"); - end - xrf = 64'hB29C35CB8E00D8E6; - y = 64'hC3402000000001FF; - zrf = 64'hC0F7FBFFFFFFFFFE; - ans = 64'hC0F7FBFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"454973\n"); - end - xrf = 64'hBFAFFFFEFFFFFFC0; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h400FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"455587\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h4800040000003FFE; - zrf = 64'hBFED31C40B4B727C; - ans = 64'hBFED31C40B4B727C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"456201\n"); - end - xrf = 64'h402206EC0CADFB89; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h3FF0000000000000; - ans = 64'h3FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"456815\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h3F0FDFFFFEFFFFFF; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"457429\n"); - end - xrf = 64'h400FF40000000000; - y = 64'hC3E00FFFEFFFFFFF; - zrf = 64'h229FEFFFFFFFF7FF; - ans = 64'hC40009F9F005FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"458043\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"458657\n"); - end - xrf = 64'h916FFFFFFFDDFFFF; - y = 64'h3FF3FFFFFEFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"459271\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h4664AF10B2B4831C; - ans = 64'h4664AF10B2B4831C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"459885\n"); - end - xrf = 64'hB03000000DFFFFFF; - y = 64'h41E0040000000200; - zrf = 64'hC034966F42C45187; - ans = 64'hC034966F42C45187; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"460499\n"); - end - xrf = 64'hC32BC7B859BF9991; - y = 64'hBCA0000000000001; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h400378F70B37F331; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"461113\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'hBFE000007DFFFFFE; - zrf = 64'hBCAFFFFFFFFFFE3F; - ans = 64'hBCAFFFFFFFFFFE3F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"461727\n"); - end - xrf = 64'hC0200000401FFFFF; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h43FFF7FFFFFFFF7F; - ans = 64'h43FFF7FFFFFFFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"462341\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h41F5D9F10DF04721; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h0225D9F10DE04720; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"462955\n"); - end - xrf = 64'h780C28A279108114; - y = 64'h65C7CB88671E9840; - zrf = 64'hC8004B04A2AE6C6C; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"463569\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'hBFD0000000000001; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h3CAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"464183\n"); - end - xrf = 64'h4023FFFFFFFC0000; - y = 64'hC02FFFFFFFDDFFFF; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"464797\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hC13FFDFFFFFFFFDF; - ans = 64'hC13FFDFFFFFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"465411\n"); - end - xrf = 64'hBFFFE003FFFFFFFE; - y = 64'h3FD0800000000000; - zrf = 64'h380FFFFBFFFFFFFF; - ans = 64'hBFE06F820FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"466025\n"); - end - xrf = 64'hBFE00000080003FF; - y = 64'hBFE0000000000000; - zrf = 64'h3FF0000000000000; - ans = 64'h3FF4000002000100; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"466639\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h47FFFFFFFFFFEBFE; - zrf = 64'h3F38CD81E06C497A; - ans = 64'h3F38CD81E06C497A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"467253\n"); - end - xrf = 64'hB810000000000803; - y = 64'hBFE0000000000001; - zrf = 64'hC3DDFFFFFFFFFFBE; - ans = 64'hC3DDFFFFFFFFFFBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"467867\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'hB80FFFFFFFF7BFFF; - zrf = 64'h8010000000000000; - ans = 64'h8010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"468481\n"); - end - xrf = 64'h3EFFFFFFFFEFFF00; - y = 64'h400000000000400F; - zrf = 64'hC8000200003FFFFF; - ans = 64'hC8000200003FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"469095\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'hBFF0000000000000; - zrf = 64'h3CA0000000000000; - ans = 64'h3CA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"469709\n"); - end - xrf = 64'h432FFFFFFFFFFF03; - y = 64'h4800000004000040; - zrf = 64'hC340000000000001; - ans = 64'h4B40000003FFFFC1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"470323\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'hBFF0000000000001; - zrf = 64'hC3FED13CC475191F; - ans = 64'hC3FED13CC475191F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"470937\n"); - end - xrf = 64'h3FEFFFFFFFDF7FFE; - y = 64'hFFF50D33EA30BABA; - zrf = 64'hB7EFFFFFFFFFFFE7; - ans = 64'hFFFD0D33EA30BABA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"471551\n"); - end - xrf = 64'h000FE0000001FFFE; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h3FE0000000000001; - ans = 64'h3FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"472165\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'hBFFFFBEFFFFFFFFF; - zrf = 64'hC1FFFFFFFFFFF80F; - ans = 64'hC1FFFFFFFFFFF80F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"472779\n"); - end - xrf = 64'h42507FFFFFFFFEFF; - y = 64'hC000000000000000; - zrf = 64'h3FA1F463B7BB4598; - ans = 64'hC2607FFFFFFFFDE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"473393\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h47FFFFFE03FFFFFF; - zrf = 64'h8000000000000001; - ans = 64'h082FFFFE03FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"474007\n"); - end - xrf = 64'h401F000000000007; - y = 64'hFFFFFEFDFFFFFFFF; - zrf = 64'h768FFFFFBFFFFF80; - ans = 64'hFFFFFEFDFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"474621\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h0010000000000001; - ans = 64'h803BFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"475235\n"); - end - xrf = 64'h43E872992068804E; - y = 64'h1ABFFDFFFFFFFFFF; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"475849\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'hC010000000000000; - zrf = 64'h43C0010080000000; - ans = 64'h43C0010080000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"476463\n"); - end - xrf = 64'h4190000000000010; - y = 64'h3FF6881A2C6EC3DE; - zrf = 64'h7FEFFFBFFEFFFFFF; - ans = 64'h7FEFFFBFFEFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"477077\n"); - end - xrf = 64'hB7F58D085BCBA2EF; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"477691\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'hC03FFFFBFFFF7FFE; - zrf = 64'h7FE000FFFFFFFBFF; - ans = 64'h7FE000FFFFFFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"478305\n"); - end - xrf = 64'h403EFFFFFFFBFFFF; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hC42DDFFFFFFFFFFF; - ans = 64'hC42DDFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"478919\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h3FCFFF0000001000; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"479533\n"); - end - xrf = 64'h380FFFFFFFFFF803; - y = 64'h4038000007FFFFFF; - zrf = 64'hBFB00000000002FF; - ans = 64'hBFB00000000002FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"480147\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h837FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"480761\n"); - end - xrf = 64'h8FCFC0000000000F; - y = 64'hC396E75DCC0BEDB1; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"481375\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h380E84D8FBC60A34; - ans = 64'h380E84D8FBC60A34; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"481989\n"); - end - xrf = 64'h402F800008000000; - y = 64'hC9200003FFFDFFFE; - zrf = 64'hC3E3B93E1C073F21; - ans = 64'hC95F8007E7FC11FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"482603\n"); - end - xrf = 64'h39B00000FFFFFF7E; - y = 64'hFFE0000000000001; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'hF9A00000FFFFFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"483217\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'h3814040000000000; - zrf = 64'hBFFB9BC145D76013; - ans = 64'hBFFB9BC145D76013; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"483831\n"); - end - xrf = 64'hB81FFFFBFFFFFFEE; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hC8BBFDFFFFFFFFFE; - ans = 64'h781FFFFBFFFFFFED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"484445\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'hC7F0002000000040; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"485059\n"); - end - xrf = 64'hBE70000000400010; - y = 64'h41298E77258CB436; - zrf = 64'hBE801FFFFFFFFFE0; - ans = 64'hBFA98E7B2DF2EE2C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"485673\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'hFFF0000000000000; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"486287\n"); - end - xrf = 64'h4FB01FFFFFFF0000; - y = 64'h3FF9AB4DFB9A7412; - zrf = 64'hC000000000000000; - ans = 64'h4FB9DEA497900E45; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"486901\n"); - end - xrf = 64'h001FFFFFFFFFFFFF; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hC04FFFFFFFFC0003; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"487515\n"); - end - xrf = 64'h43FFF2FFF2870904; - y = 64'h8B97AB5EF0099570; - zrf = 64'hBA5FEFFBFFFFFFFE; - ans = 64'hBA5FEFFBFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"488129\n"); - end - xrf = 64'h41E020000007FFFF; - y = 64'h0000000000000000; - zrf = 64'h3CA0000000000000; - ans = 64'h3CA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"488743\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hC3D6A3A9253C9470; - zrf = 64'h3FB000000000013F; - ans = 64'h3FB000000000013F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"489357\n"); - end - xrf = 64'hDC10000000001EFF; - y = 64'h0000000000000001; - zrf = 64'h802D63F274ADA691; - ans = 64'h98F0000000001EFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"489971\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hBFC007FFFFFFFFFB; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"490585\n"); - end - xrf = 64'hBFD200007FFFFFFF; - y = 64'hC34B916DE7248984; - zrf = 64'hC1CF67F6D68E7232; - ans = 64'h432F039C02F4AE92; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"491199\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"491813\n"); - end - xrf = 64'h408FFFFFFFF003FF; - y = 64'hBFF01DFFFFFFFFFF; - zrf = 64'hBFF0000000000001; - ans = 64'hC09021FFFFF7F302; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"492427\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h0010000000000001; - zrf = 64'h800E000000002000; - ans = 64'h800E000000002000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"493041\n"); - end - xrf = 64'hC1CFFFFFEFFDFFFF; - y = 64'h402DFFFFFFFFFF80; - zrf = 64'hC1D00400003FFFFF; - ans = 64'hC210003FF8830FBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"493655\n"); - end - xrf = 64'h3FD3D4BA52CE9C8D; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h0010000000000001; - ans = 64'h0019EA5D29674E47; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"494269\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h801FFFFFFFFFFC7E; - zrf = 64'hC00FFFFFFFFFFDDF; - ans = 64'hC00FFFFFFFFFFDDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"494883\n"); - end - xrf = 64'h0C8FFFFC000000FF; - y = 64'h3CA0000000000000; - zrf = 64'hC051E56F7DD285F6; - ans = 64'hC051E56F7DD285F6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"495497\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hBFEFFFFE07FFFFFE; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"496111\n"); - end - xrf = 64'hC02FFFFFFFC01FFF; - y = 64'hC7CF107CC9D31F6F; - zrf = 64'h801E5BA459AF6A18; - ans = 64'h480F107CC9951D85; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"496725\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"497339\n"); - end - xrf = 64'h7FEDD366C08DD3A9; - y = 64'hC28FFFDEFFFFFFFF; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"497953\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h3FD0000000000000; - zrf = 64'hBFEFF5FFFFFFFFFF; - ans = 64'hBFEFF5FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"498567\n"); - end - xrf = 64'h3FF0000000200FFF; - y = 64'hC7E0FFFFFFFF0000; - zrf = 64'hC352890E4983B6C0; - ans = 64'hC7E10000002110FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"499181\n"); - end - xrf = 64'hB815E5AD5F1699AF; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hB805E5AD5F1699AE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"499795\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hBFC010000000000F; - zrf = 64'h3FE0000017FFFFFF; - ans = 64'h3FE0000017FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"500409\n"); - end - xrf = 64'hC3F000000000BFFE; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h3F4FFFFFFFFFFF3E; - ans = 64'hC3E000000000BFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"501023\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hC03FC01000000000; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h401FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"501637\n"); - end - xrf = 64'h801000009FFFFFFE; - y = 64'h452CFCD0228D0030; - zrf = 64'h7FD000FFFFFF8000; - ans = 64'h7FD000FFFFFF8000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"502251\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h3FE0000000000001; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"502865\n"); - end - xrf = 64'hBF844323FF911B3D; - y = 64'h8E2FFFFFF0000002; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"503479\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'hFFE00020000003FF; - ans = 64'hFFE00020000003FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"504093\n"); - end - xrf = 64'hC66000FFFBFFFFFE; - y = 64'h44F0003FEFFFFFFF; - zrf = 64'h41DFFFFFFC0007FE; - ans = 64'hCB60013FEFFEF001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"504707\n"); - end - xrf = 64'h3847AC8111864E13; - y = 64'h3FF0000000000000; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"505321\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h47EFFFFFFF400000; - zrf = 64'h39D801FFFFFFFFFE; - ans = 64'h39D801FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"505935\n"); - end - xrf = 64'hA4C0020003FFFFFF; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hC3DFFEFFFFFDFFFF; - ans = 64'hC3DFFEFFFFFDFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"506549\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hFFF000100000003F; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'hFFF800100000003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"507163\n"); - end - xrf = 64'h40300000101FFFFF; - y = 64'h403CC2DCC09CCB9F; - zrf = 64'hBFFFFFFFF8000100; - ans = 64'h407CA2DCDDA12E16; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"507777\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h4000000000000000; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"508391\n"); - end - xrf = 64'h3FF0000000000806; - y = 64'hBFE00000000000FF; - zrf = 64'hBFD0000000000000; - ans = 64'hBFE8000000000905; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"509005\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h3FEBFFFFC0000000; - ans = 64'h3FEBFFFFC0000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"509619\n"); - end - xrf = 64'h8E70000000080004; - y = 64'hBF4FFFFFFFC0001E; - zrf = 64'hC03FFFF000000001; - ans = 64'hC03FFFF000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"510233\n"); - end - xrf = 64'hFFF7211EB044CF02; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hFFF0000000000000; - ans = 64'hFFFF211EB044CF02; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"510847\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hBFCBFF7FFFFFFFFF; - zrf = 64'h43C0040000007FFE; - ans = 64'h43C0040000007FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"511461\n"); - end - xrf = 64'hC123FFFFFBFFFFFF; - y = 64'h4010000000000001; - zrf = 64'hC8000001FFFFFFEF; - ans = 64'hC8000001FFFFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"512075\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h41CFFFFE00001FFE; - zrf = 64'h4000000000000000; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"512689\n"); - end - xrf = 64'h2AECFBC4733AA5DB; - y = 64'hC02FFDFFFFF7FFFF; - zrf = 64'hDD107FFFFFF7FFFF; - ans = 64'hDD107FFFFFF7FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"513303\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"513917\n"); - end - xrf = 64'hBFE007FFFFFFFFEF; - y = 64'h80200000000000FF; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"514531\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h4340000000000001; - zrf = 64'h43DFFFE00007FFFF; - ans = 64'h43DFFFE00007FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"515145\n"); - end - xrf = 64'hBCAFFFFFFFFC0FFE; - y = 64'h37E0FFFFFFC00000; - zrf = 64'hBFB3A6E10298147B; - ans = 64'hBFB3A6E10298147B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"515759\n"); - end - xrf = 64'hBFD00000000200FE; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"516373\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h3FE02FFFFFFFFFFE; - zrf = 64'h328FBFFFFFFFFEFE; - ans = 64'h328FBFFFFFFFFEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"516987\n"); - end - xrf = 64'hC2BFF00000000006; - y = 64'h7FE0000000000000; - zrf = 64'h3F6FFC00000FFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"517601\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hBFB0000000000000; - zrf = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"518215\n"); - end - xrf = 64'hC03FFFFFFFFFC00E; - y = 64'hC1C000007C000000; - zrf = 64'h434FFFFDFFFDFFFF; - ans = 64'h434FFFFFFFFE0F7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"518829\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; + x = 64'hC01FF00000000080; y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hC000000000000001; - ans = 64'h4017FFFFFFFFFFFD; + z = 64'h38DFFFFF70000000; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -39773,19 +10490,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -39801,12 +10518,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"519443\n"); + $fwrite(fp,"449121\n"); end - xrf = 64'h801FFBFFFFDFFFFE; - y = 64'h002C7FFFFFFFFFFE; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h801FFFFFFFFFFFFF; + x = 64'h47E0001FFFFFFDFF; + y = 64'hBA7FFF007FFFFFFF; + z = 64'h3F1FC3FFFFFFFFFE; + ans = 64'hC26FFF407E00FBFC; rn = 1; rz = 0; rm = 0; @@ -39820,19 +10537,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -39848,199 +10565,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"520057\n"); + $fwrite(fp,"451135\n"); end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h7FF0000000000000; - zrf = 64'hC4A7AD9414DA3394; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"520671\n"); - end - xrf = 64'hC07815AA5F6B0FEC; - y = 64'hC8F0000007FBFFFE; - zrf = 64'h381FFFC0000FFFFE; - ans = 64'h497815AA6B6FDFAE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"521285\n"); - end - xrf = 64'h41E833C7BBCD2C9D; - y = 64'h7FF0000000000001; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"521899\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h3FE8001FFFFFFFFE; - zrf = 64'h3EEF8000001FFFFF; - ans = 64'h3EEF8000001FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"522513\n"); - end - xrf = 64'h40CFFFEFFFFFFC00; + x = 64'h001FFFFFFFFFFFFF; y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'hC7EFFFFFF5FFFFFE; + z = 64'hC340000000000000; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -40055,19 +10584,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -40083,12 +10612,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"523127\n"); + $fwrite(fp,"453149\n"); end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hC3FFFFFC001FFFFF; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FEFFFFFFFFFFFFF; + x = 64'h4F70000000040001; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h1FCFFFFE00FFFFFF; + ans = 64'h1FCFFFFE00FFFFFF; rn = 1; rz = 0; rm = 0; @@ -40102,19 +10631,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -40130,12 +10659,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"523741\n"); + $fwrite(fp,"455163\n"); end - xrf = 64'hC0BFFFFFFDFFC000; - y = 64'h37E00080000003FF; - zrf = 64'h480D3EE09C1ED5B4; - ans = 64'h480D3EE09C1ED5B4; + x = 64'hC09000FFFFFBFFFE; + y = 64'h4020000FFFFFFFEE; + z = 64'h3FD0803FFFFFFFFF; + ans = 64'hC0C000EF007BFFE8; rn = 1; rz = 0; rm = 0; @@ -40149,19 +10678,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -40177,12 +10706,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"524355\n"); + $fwrite(fp,"457177\n"); end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h8000000000000001; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; + x = 64'h001FFFFFFFFFFFFF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -40196,19 +10725,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -40224,482 +10753,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"524969\n"); + $fwrite(fp,"459191\n"); end - xrf = 64'h380FFFFFBFFFFFF7; - y = 64'h41D000000FBFFFFF; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h39EFFFFFDF7FFFB6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"525583\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h4007A97DE77E4C18; - ans = 64'h4007A97DE77E4C18; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"526197\n"); - end - xrf = 64'hC3F3FFFF7FFFFFFE; - y = 64'h47EFFFFF000001FF; - zrf = 64'hC0301FFFFC000000; - ans = 64'hCBF3FFFEE000053D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"526811\n"); - end - xrf = 64'h41CFB516C073EDBC; - y = 64'h8010000000000000; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"527425\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h2E8FFFFEC0000000; - zrf = 64'h40E090744244D531; - ans = 64'h40E090744244D531; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"528039\n"); - end - xrf = 64'h46910000003FFFFF; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'hC008371E39861C0C; - ans = 64'hC008371E39861C0C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"528653\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h002F50F3A5D280F0; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"529267\n"); - end - xrf = 64'h41F0000000001000; - y = 64'hBE00000001F7FFFF; - zrf = 64'hC00DD214F016BF5E; - ans = 64'hC016E90A790767AF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"529881\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hBCA0000000000000; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hBFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"530495\n"); - end - xrf = 64'hBFDA764348037620; - y = 64'h380E00000000000F; - zrf = 64'h8000000000000000; - ans = 64'hB7F8CEDF13833ECA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"531109\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; + x = 64'hC0300000020000FF; y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h4FC000000080003F; - ans = 64'h4FC000000080003F; + z = 64'hC1C00000020003FF; + ans = 64'hC1C00000020003FF; rn = 1; rz = 0; rm = 0; @@ -40713,19 +10772,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -40741,12 +10800,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"531723\n"); + $fwrite(fp,"461205\n"); end - xrf = 64'hBFDF80000007FFFE; - y = 64'hA1F0000004003FFE; - zrf = 64'h40200000000003FC; - ans = 64'h40200000000003FC; + x = 64'h4031B1054AFF739B; + y = 64'hFFD0000080000004; + z = 64'hBFE000010FFFFFFE; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -40760,19 +10819,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -40788,247 +10847,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"532337\n"); + $fwrite(fp,"463219\n"); end - xrf = 64'h2860008007FFFFFE; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"532951\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h403123775A6D2DD2; - zrf = 64'h3CA0000000000401; - ans = 64'h3CA0000000000401; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"533565\n"); - end - xrf = 64'h8AD00003FFF7FFFF; - y = 64'hBFD0000000000001; - zrf = 64'h48C7FFFFFFFFFEFF; - ans = 64'h48C7FFFFFFFFFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"534179\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hC19001FFFF7FFFFE; - zrf = 64'h3FD0000000000000; - ans = 64'h3FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"534793\n"); - end - xrf = 64'hBDEF6966E82E31CA; - y = 64'hFFD169C9EC6EC12F; - zrf = 64'h3FBFFFFFFFFFFAFE; - ans = 64'h7DD117D6BB26D34D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"535407\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; + x = 64'h001FFFFFFFFFFFFF; y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -41042,19 +10866,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -41070,59 +10894,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"536021\n"); + $fwrite(fp,"465233\n"); end - xrf = 64'hB7FE475C439E7B31; - y = 64'h40AFFFE000000003; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"536635\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; + x = 64'h49F200000000FFFF; y = 64'hBFE0000000000001; - zrf = 64'hC0B00000007FEFFF; - ans = 64'hC0B00000007FEFFF; + z = 64'hAEF0007FFFFFFFDF; + ans = 64'hC9E2000000010000; rn = 1; rz = 0; rm = 0; @@ -41136,19 +10913,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -41164,12 +10941,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"537249\n"); + $fwrite(fp,"467247\n"); end - xrf = 64'hC1DFFFFFF0000008; - y = 64'hBFCFFFDFFFFFFFF7; - zrf = 64'h3F9FEFFFFFFFFFFF; - ans = 64'h41BFFFDFF0080BFF; + x = 64'h3D9AAC08F7E44873; + y = 64'h2DC07FFFFF800000; + z = 64'hC36FFFFFFF800000; + ans = 64'hC36FFFFFFF800000; rn = 1; rz = 0; rm = 0; @@ -41183,19 +10960,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -41211,247 +10988,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"537863\n"); + $fwrite(fp,"469261\n"); end - xrf = 64'h3FC03FFFFEFFFFFE; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hC000000000000001; - ans = 64'hC00103FFFFF00001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"538477\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hC3EFBFFFFFFFDFFE; - zrf = 64'h413003FFEFFFFFFF; - ans = 64'h413003FFEFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"539091\n"); - end - xrf = 64'hBCAFFFFFFF7FFF7F; - y = 64'hBFF0000000000000; - zrf = 64'hC01FFFFF80000400; - ans = 64'hC01FFFFF80000400; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"539705\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hBD0FFFEFFFFFC000; - zrf = 64'h3CA0000000000001; - ans = 64'h3CA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"540319\n"); - end - xrf = 64'hBFB0807FFFFFFFFF; - y = 64'h1FE000000003FC00; - zrf = 64'h3FBCE60789BFE91F; - ans = 64'h3FBCE60789BFE91F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"540933\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; + x = 64'h001FFFFFFFFFFFFF; y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'hBFD0000000000001; - ans = 64'hBFD0000000000001; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; rn = 1; rz = 0; rm = 0; @@ -41465,19 +11007,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -41493,153 +11035,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"541547\n"); + $fwrite(fp,"471275\n"); end - xrf = 64'h40D000201FFFFFFF; - y = 64'hC050000800010000; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"542161\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hC000000000000000; - zrf = 64'hC027B5C169FB9BF9; - ans = 64'hC027B5C169FB9BF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"542775\n"); - end - xrf = 64'h3FF000001FFFFFFB; - y = 64'h7FFFFFFFFBFFFDFF; - zrf = 64'h7FF00001FBFFFFFF; - ans = 64'h7FFFFFFFFBFFFDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"543389\n"); - end - xrf = 64'h4020001FFFFFFFBF; + x = 64'h3FBF8000001FFFFE; y = 64'hC000000000000001; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hC032001FFFFFFFC0; + z = 64'h37E00000007FEFFE; + ans = 64'hBFCF800000200000; rn = 1; rz = 0; rm = 0; @@ -41653,19 +11054,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -41681,12 +11082,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"544003\n"); + $fwrite(fp,"473289\n"); end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hC01FFFFFFE000001; - zrf = 64'hB806F34352FD18A5; - ans = 64'hB806F34352FD18A5; + x = 64'h8020007FFDFFFFFF; + y = 64'h9BEFFFF7FFF7FFFE; + z = 64'h000FFFFFFFF7FFFE; + ans = 64'h000FFFFFFFF7FFFE; rn = 1; rz = 0; rm = 0; @@ -41700,19 +11101,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -41728,622 +11129,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"544617\n"); + $fwrite(fp,"475303\n"); end - xrf = 64'hC02000003FFFBFFF; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'hBFE00001000003FE; - ans = 64'h403F800077FF7FDC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"545231\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h357FFFFFEFFFFFFC; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h001FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"545845\n"); - end - xrf = 64'hFFDEFFFFFFFFEFFE; - y = 64'h37FFFFF7FFFFFF80; - zrf = 64'h41DFFFFBFFFE0000; - ans = 64'hF7EEFFF83FFFEF82; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"546459\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hC010000000000001; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"547073\n"); - end - xrf = 64'h41FDFFABFA74E0B2; - y = 64'hBFDC6DD0BA79DD66; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFF95655BD7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"547687\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hB81FFFFFFFF77FFE; - ans = 64'hB81FFFFFFFF77FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"548301\n"); - end - xrf = 64'h3FB0107FFFFFFFFF; - y = 64'h80100FFFFFFFFFDE; - zrf = 64'hC3E0100010000000; - ans = 64'hC3E0100010000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"548915\n"); - end - xrf = 64'hC3FFFFE00000003E; - y = 64'hC340000000000000; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'h474FFFE00000003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"549529\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h3FFFFFEFF0000000; - zrf = 64'hFFEF80FFFFFFFFFF; - ans = 64'hFFEF80FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"550143\n"); - end - xrf = 64'h43C0660CA00BB7AA; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h3ED00000FF7FFFFF; - ans = 64'hC720660CA00BB7A9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"550757\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'h3FDDFBFFFFFFFFFF; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h001EFDFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"551371\n"); - end - xrf = 64'hBA57FFFFFFFFFBFF; - y = 64'h3FCED58246AC34ED; - zrf = 64'h380B7EF6003637E4; - ans = 64'hBA372021B4FDB3F7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"551985\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hFFE0000000000000; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"552599\n"); - end - xrf = 64'h43C00000000FBFFF; - y = 64'h8000043FFFFFFFFF; - zrf = 64'h4340000000000000; + x = 64'h001FFFFFFFFFFFFF; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h4340000000000000; ans = 64'h4340000000000000; rn = 1; rz = 0; @@ -42358,19 +11148,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -42386,12 +11176,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"553213\n"); + $fwrite(fp,"477317\n"); end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hC1C3414AF94B6C96; - ans = 64'hC1C3414AFD4B6C96; + x = 64'hBA00000000047FFF; + y = 64'hC340000000000000; + z = 64'hC08020000000001F; + ans = 64'hC08020000000001D; rn = 1; rz = 0; rm = 0; @@ -42405,19 +11195,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -42433,12 +11223,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"553827\n"); + $fwrite(fp,"479331\n"); end - xrf = 64'h3E0FFFFFF800000E; - y = 64'hC00FFFFF7FFFFFFF; - zrf = 64'h37EFFFFFFFF83FFF; - ans = 64'hBE2FFFFF7800002D; + x = 64'h3FF0100FFFFFFFFE; + y = 64'hFD2F1CCF1749CC84; + z = 64'hBFF7FFFFFFFFFFFD; + ans = 64'hFD2F3C0B03302D96; rn = 1; rz = 0; rm = 0; @@ -42452,19 +11242,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -42480,246 +11270,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"554441\n"); + $fwrite(fp,"481345\n"); end - xrf = 64'h0020000000000240; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'hBFE0000000000000; - ans = 64'hC02100000000023F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"555055\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hBFF00800000FFFFE; - zrf = 64'hBFBFFFFF7FFDFFFF; - ans = 64'hBFBFFFFF7FFDFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"555669\n"); - end - xrf = 64'hBFEFFEFFFFFF0000; - y = 64'hFFF0000000000001; - zrf = 64'hBFD0010001FFFFFF; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"556283\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hBFE942E0EAAF09E3; - zrf = 64'h0000000000000000; - ans = 64'h801942E0EAAF09E1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"556897\n"); - end - xrf = 64'h43420003FFFFFFFF; - y = 64'hC06000FFFFFFFFF7; - zrf = 64'hFFF0000201FFFFFF; - ans = 64'hFFF8000201FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"557511\n"); - end - xrf = 64'h001FFFFFFFFFFFFE; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h8010000000000000; + x = 64'h001FFFFFFFFFFFFF; + y = 64'hFFE0000000000001; + z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -42734,19 +11289,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -42762,12 +11317,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"558125\n"); + $fwrite(fp,"483359\n"); end - xrf = 64'hBF80007FFFFFFFBF; - y = 64'hC340000000017FFE; - zrf = 64'h4010000000000001; - ans = 64'h42D00080000180C9; + x = 64'h001BE8CBEEBEC207; + y = 64'hFFF0000000000000; + z = 64'hB7FEFFFBFFFFFFFF; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -42781,19 +11336,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -42809,528 +11364,58 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"558739\n"); + $fwrite(fp,"485373\n"); end - xrf = 64'h3CA0000000000000; + x = 64'hC7E00000003FEFFF; + y = 64'hBB542AAFA393CD33; + z = 64'hBCE007FFFFFFEFFF; + ans = 64'h43442AAFA3E463C6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"487387\n"); + end + x = 64'h001FFFFFFFFFFFFE; y = 64'h0000000000000001; - zrf = 64'h000E8D6AC606E59D; - ans = 64'h000E8D6AC606E59D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"559353\n"); - end - xrf = 64'h403FFFFFFFFFFF76; - y = 64'hB7EFFFF00000007F; - zrf = 64'hC80846C2B939D9A3; - ans = 64'hC80846C2B939D9A3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"559967\n"); - end - xrf = 64'hB7F0040001FFFFFE; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'hBFD0000000000001; - ans = 64'hBFD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"560581\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'hA2DD81347EA0D30C; - zrf = 64'hBE9000000007FFFB; - ans = 64'hBE9000000007FFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"561195\n"); - end - xrf = 64'h3FD4FEF9A261B85F; - y = 64'h0010000000000000; - zrf = 64'hC1FFFFEFFFFFFFF6; - ans = 64'hC1FFFFEFFFFFFFF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"561809\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'hC3DFFFFFFFFFFFFE; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"562423\n"); - end - xrf = 64'hC3F007F000000000; - y = 64'hA9AFFFFDFFFF7FFF; - zrf = 64'h47EFFF0010000000; - ans = 64'h47EFFF0010000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"563037\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h8000000000000001; - ans = 64'h8000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"563651\n"); - end - xrf = 64'h403FFFFF8007FFFF; - y = 64'hC1D000001FFFFFDF; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'hC21FFFFFBFF7FEBD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"564265\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h3CA0000000000000; - zrf = 64'h4E60000001FFFF7F; - ans = 64'h4E60000001FFFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"564879\n"); - end - xrf = 64'h37F000000037FFFE; - y = 64'h3CAFFFC000000008; - zrf = 64'hCC40000800003FFE; - ans = 64'hCC40000800003FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"565493\n"); - end - xrf = 64'h001FFFF7FFFDFFFF; - y = 64'h3CA0000000000001; - zrf = 64'hBCAFFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; ans = 64'hBCAFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -43345,19 +11430,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -43373,12 +11458,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"566107\n"); + $fwrite(fp,"489401\n"); end - xrf = 64'h3CA0000000000000; - y = 64'hBF3FF7FFFFFEFFFF; - zrf = 64'h33DFFFFFF00003FE; - ans = 64'hBBEFF7FFFFFEFFFF; + x = 64'h729F7FFFFFFFFFF0; + y = 64'h0010000000000000; + z = 64'h43F40FFFFFFFFFFF; + ans = 64'h43F40FFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -43392,19 +11477,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -43420,12 +11505,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"566721\n"); + $fwrite(fp,"491415\n"); end - xrf = 64'hFFDFFF7FFFFFFDFF; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'hC3D0000000000780; - ans = 64'hFC9FFF7FFFFFFDFD; + x = 64'h412FF7FFFFFFEFFE; + y = 64'h3FD785891B76C59A; + z = 64'h3A200007FFFF7FFF; + ans = 64'h41177FA7B92FDC24; rn = 1; rz = 0; rm = 0; @@ -43439,19 +11524,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -43467,3066 +11552,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"567335\n"); + $fwrite(fp,"493429\n"); end - xrf = 64'h3CA0000000000000; - y = 64'hC02B75AA8C7CE7CF; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"567949\n"); - end - xrf = 64'h3DAA778B91CB7508; - y = 64'h41DDE00000000000; - zrf = 64'hA5A5E0EEE55BDC4F; - ans = 64'h3F98B59B4D1CF242; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"568563\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h3FD0000000000001; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"569177\n"); - end - xrf = 64'hC0B2B61F5E89F40A; - y = 64'h3FE0001FFFFFFDFF; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'hC0A2B244CAC8AEC6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"569791\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'hC1E00000000010FF; - ans = 64'hC1E00000000010FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"570405\n"); - end - xrf = 64'hBEDBFF0000000000; - y = 64'h41CFFFFFFFFFFF7F; - zrf = 64'hC80000000FFFFFEE; - ans = 64'hC80000000FFFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"571019\n"); - end - xrf = 64'hC1F000000401FFFE; - y = 64'h3FE0000000000000; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'hC1E000000401FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"571633\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h3FDFFFAFFFFFFFFF; - zrf = 64'h802FA574C852AFD8; - ans = 64'h3C8FFFAFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"572247\n"); - end - xrf = 64'h3FD0010000020000; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h3A4FFEFFFFFDFFFE; - ans = 64'h3FD001000001FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"572861\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h3FD04001FFFFFFFF; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"573475\n"); - end - xrf = 64'hC1D0000007FFFFBE; - y = 64'h41A03FFFF0000000; - zrf = 64'h41CFFFFFFC000100; - ans = 64'hC3803FFFF61FFFB5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"574089\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h3FF0000000000000; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"574703\n"); - end - xrf = 64'h7FD000000000400F; - y = 64'hFD5FFFDFFE000000; - zrf = 64'h3FF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"575317\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hC34FFFFFFDFFFFFD; - ans = 64'hC34FFFFFFDFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"575931\n"); - end - xrf = 64'hB60FF7FFFF7FFFFF; - y = 64'h3F0F0000000007FF; - zrf = 64'h40101FFFDFFFFFFF; - ans = 64'h40101FFFDFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"576545\n"); - end - xrf = 64'hC3EFFFFFFFF7FBFE; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h8010000000000000; - ans = 64'hC3FFFFFFFFF7FBFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"577159\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'hAC9FFFFFFFF80000; - zrf = 64'h40EFFFFFFFFFF77F; - ans = 64'h40EFFFFFFFFFF77F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"577773\n"); - end - xrf = 64'h07B00000007FFFFE; - y = 64'h4000000000000001; - zrf = 64'h3B20000000FEFFFE; - ans = 64'h3B20000000FEFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"578387\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h002FC000000000FF; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"579001\n"); - end - xrf = 64'h3CCFF7FFFFFBFFFF; - y = 64'hBA90000100000080; - zrf = 64'h41E00000007FF7FF; - ans = 64'h41E00000007FF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"579615\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"580229\n"); - end - xrf = 64'hBFCFFFFFFFF3FFFF; - y = 64'h40100000000100FF; - zrf = 64'h3FE0000000000001; - ans = 64'hBFDFFFFFFFEC03F8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"580843\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h4010000000000000; - zrf = 64'h407FFFFC1FFFFFFE; - ans = 64'h407FFFFC1FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"581457\n"); - end - xrf = 64'h43C047F600C3F7AA; - y = 64'h3732487BBFBF6EAC; - zrf = 64'hBFFFFFFFFFFFFDFB; - ans = 64'hBFFFFFFFFFFFFDFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"582071\n"); - end - xrf = 64'hFFF0080000001FFE; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h8000000000000001; - ans = 64'hFFF8080000001FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"582685\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h3CAE2400053CB0F9; - zrf = 64'hBF8FFFFFFFFDDFFE; - ans = 64'hBF8FFFFFFFFDDFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"583299\n"); - end - xrf = 64'hC00FE00000000FFF; - y = 64'h4340000000000000; - zrf = 64'hBFEBFFC000000000; - ans = 64'hC35FE00000000FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"583913\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'hC0800003FFF80000; - zrf = 64'hC010000000000001; - ans = 64'hC010000000000041; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"584527\n"); - end - xrf = 64'hBFBFFFFFFFDFFFFE; - y = 64'h3FD01000001FFFFF; - zrf = 64'hBF9FFFFFFF803FFE; - ans = 64'hBFB007FFFFE807FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"585141\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"585755\n"); - end - xrf = 64'h47BFFFFFFFC00800; - y = 64'hC0500007FFFFBFFF; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'hC8200007FFDFC3EF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"586369\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hC019CAB46F8C90A7; - ans = 64'hC011CAB46F8C90A8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"586983\n"); - end - xrf = 64'h8020200000000080; - y = 64'h4C9FE00000010000; - zrf = 64'hBFE000013FFFFFFF; - ans = 64'hBFE000013FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"587597\n"); - end - xrf = 64'h43D0000000007BFF; - y = 64'h7FE0000000000001; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"588211\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'hB09002000000003E; - zrf = 64'h37F002000000001F; - ans = 64'h37F002000000001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"588825\n"); - end - xrf = 64'h43CFFFFC00400000; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h380FFFFFFFFFFBFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"589439\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h41EBFF0000000000; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC00FFFFFC801FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"590053\n"); - end - xrf = 64'h400F800FFFFFFFFF; - y = 64'hA991FFFFFFC00000; - zrf = 64'hC15DFFFFFFFDFFFE; - ans = 64'hC15DFFFFFFFDFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"590667\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h7FF0000000000001; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"591281\n"); - end - xrf = 64'hBCAC000003FFFFFF; - y = 64'hC3C00080000003FF; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h407C00E0040026FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"591895\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h4103E839DCCFFAEF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"592509\n"); - end - xrf = 64'hAEA03FFFFFFFFFFD; - y = 64'h800FFFFFFFF7BFFF; - zrf = 64'h801000007FFFFE00; - ans = 64'h801000007FFFFE00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"593123\n"); - end - xrf = 64'h43CFFFFE0001FFFF; - y = 64'h8000000000000000; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"593737\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'hC000002000000FFF; - zrf = 64'hB37EFDFFFFFFFFFF; - ans = 64'hBCB0002000000FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"594351\n"); - end - xrf = 64'h47EFC142A7AA9FC5; - y = 64'h8000000000000001; - zrf = 64'hBFA36F59B827AA2E; - ans = 64'hBFA36F59B827AA2E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"594965\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'hBFC0FFFFFFFFFFEF; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hBFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"595579\n"); - end - xrf = 64'h3CAFFBFFFFFFFF7F; - y = 64'h7FFFFC0000000008; - zrf = 64'hC1CFFFC0003FFFFE; - ans = 64'h7FFFFC0000000008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"596193\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h8010000000000000; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"596807\n"); - end - xrf = 64'h37FFFFFFFFDFFC00; - y = 64'h400F7FFFFFFF7FFF; - zrf = 64'h3CA0000000000000; - ans = 64'h3CA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"597421\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h8010000000000001; - zrf = 64'hC1A000000000080F; - ans = 64'hC1A000000000080F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"598035\n"); - end - xrf = 64'h3FA0000003FFFFEE; - y = 64'h3FB8B9A055DED013; - zrf = 64'hBC0FFFFFF0020000; - ans = 64'h3F68B9A05C0D380C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"598649\n"); - end - xrf = 64'hC03FBFFFFFFFF800; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"599263\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'hC0B87E66EFF0F1FE; - zrf = 64'hC3E000FFFFFEFFFF; - ans = 64'hC3E000FFFFFEFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"599877\n"); - end - xrf = 64'h001400000000001F; - y = 64'hBCA0000000000000; - zrf = 64'hDA2B647026EEBA96; - ans = 64'hDA2B647026EEBA96; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"600491\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h1F30403FFFFFFFFF; - zrf = 64'hBFF0000000000000; - ans = 64'hBFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"601105\n"); - end - xrf = 64'hC1C5EEED585AABCE; - y = 64'h400FFFFFF77FFFFE; - zrf = 64'h480FF08000000000; - ans = 64'h480FF08000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"601719\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h4000000000000000; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"602333\n"); - end - xrf = 64'h3B4B2B5E46FAE16F; - y = 64'hC1EC0007FFFFFFFF; - zrf = 64'h0010000000000001; - ans = 64'hBD47C5F948F316FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"602947\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'hBFD0000000000000; - zrf = 64'h3E90D05E2957F142; - ans = 64'h3E90D05E294FF142; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"603561\n"); - end - xrf = 64'hBFDF80003FFFFFFF; - y = 64'hBFB003FFFEFFFFFF; - zrf = 64'h3CAFFE0000000200; - ans = 64'h3F9F87E03E180039; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"604175\n"); - end - xrf = 64'hB7EFFFFFFE00000F; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"604789\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h3F90000080FFFFFE; - zrf = 64'hC03000000010007E; - ans = 64'hC03000000010007E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"605403\n"); - end - xrf = 64'hB805AF0434902F3C; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h478B9FDB62B52236; - ans = 64'h478B9FDB62B52236; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"606017\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h402E00001FFFFFFF; - zrf = 64'hBFE0000000000001; - ans = 64'hBFDFFFFFFFFFFFE4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"606631\n"); - end - xrf = 64'hBFCFFFFF6FFFFFFE; - y = 64'h4052E8AF709A9CA0; - zrf = 64'hC17003FFFFFFFFE0; - ans = 64'hC17004012E8AF198; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"607245\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h3FF0000000000001; + x = 64'h001FFFFFFFFFFFFE; + y = 64'h3CA0000000000001; + z = 64'h3FF0000000000001; ans = 64'h3FF0000000000001; rn = 1; rz = 0; @@ -46541,19 +11571,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -46569,12 +11599,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"607859\n"); + $fwrite(fp,"495443\n"); end - xrf = 64'h43443177992F047A; - y = 64'hBFCD6E643DF27728; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hC322927DAF9E39A7; + x = 64'h660000000010003F; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h40F80003FFFFFFFF; + ans = 64'h62C000000010003E; rn = 1; rz = 0; rm = 0; @@ -46588,19 +11618,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -46616,12 +11646,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"608473\n"); + $fwrite(fp,"497457\n"); end - xrf = 64'h3CA0000000000000; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hBFFFFF7FFFFFE000; - ans = 64'hBFFFFF7FFFFFE000; + x = 64'h49CFFF8007FFFFFF; + y = 64'hC7F09FFFFFFFFFFF; + z = 64'h3F1FFFFFFBFFFE00; + ans = 64'hD1D09FBD8427FFFE; rn = 1; rz = 0; rm = 0; @@ -46635,19 +11665,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -46663,12 +11693,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"609087\n"); + $fwrite(fp,"499471\n"); end - xrf = 64'hFFDF8000000003FE; - y = 64'h7FE0000000040200; - zrf = 64'hC1EFFE0000000FFF; - ans = 64'hFFF0000000000000; + x = 64'h001FFFFFFFFFFFFE; + y = 64'h3FE0000000000000; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; rn = 1; rz = 0; rm = 0; @@ -46682,19 +11712,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -46710,12 +11740,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"609701\n"); + $fwrite(fp,"501485\n"); end - xrf = 64'h47DF0FB4968EC67D; - y = 64'hBFF0000000000001; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'hC7DF0FB4968EC67F; + x = 64'h3F4000100000003F; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h422FF00000007FFF; + ans = 64'h422FF0000000803F; rn = 1; rz = 0; rm = 0; @@ -46729,19 +11759,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -46757,12 +11787,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"610315\n"); + $fwrite(fp,"503499\n"); end - xrf = 64'h3CA0000000000000; - y = 64'h40C0040004000000; - zrf = 64'h40071DA282D7133B; - ans = 64'h40071DA282D71B3D; + x = 64'h48700001FBFFFFFE; + y = 64'hBFCFFFFFFC000400; + z = 64'hC05BFFFFFFFFFBFE; + ans = 64'hC8500001FA0001BF; rn = 1; rz = 0; rm = 0; @@ -46776,19 +11806,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -46804,12 +11834,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"610929\n"); + $fwrite(fp,"505513\n"); end - xrf = 64'h801FFFFFFFFFBFEF; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'hC80FEFFFEFFFFFFF; - ans = 64'hC80FEFFFEFFFFFFF; + x = 64'h001FFFFFFFFFFFFE; + y = 64'h4000000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -46823,19 +11853,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -46851,12 +11881,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"611543\n"); + $fwrite(fp,"507527\n"); end - xrf = 64'h3CA0000000000000; - y = 64'h434FFFFFFEFFFDFF; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'h3FF7FFFFFEFFFDFF; + x = 64'h41C00000001003FF; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h3CA7FFFBFFFFFFFF; + ans = 64'h41E00000001003FE; rn = 1; rz = 0; rm = 0; @@ -46870,19 +11900,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -46898,12 +11928,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"612157\n"); + $fwrite(fp,"509541\n"); end - xrf = 64'hBF90000FFFFFFFFF; - y = 64'hBF13C4AABD3B8972; - zrf = 64'h802FFFE0007FFFFF; - ans = 64'h3EB3C4BE81E646AC; + x = 64'h41D0000000080200; + y = 64'hE53FFFF7FFFFFFE0; + z = 64'h44E00000401FFFFE; + ans = 64'hE71FFFF8001003DC; rn = 1; rz = 0; rm = 0; @@ -46917,19 +11947,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -46945,12 +11975,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"612771\n"); + $fwrite(fp,"511555\n"); end - xrf = 64'h3CA0000000000000; - y = 64'hC000000000000001; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FEFFFFFFFFFFFFD; + x = 64'h001FFFFFFFFFFFFE; + y = 64'h4340000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -46964,19 +11994,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -46992,11 +12022,387 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"613385\n"); + $fwrite(fp,"513569\n"); end - xrf = 64'hA333A1B8F786C499; - y = 64'h3E6FFFFF007FFFFE; - zrf = 64'hFFFFFFFFFFFFFFFE; + x = 64'hC340000000007F7F; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hBFEFFFFFFFEFFFFA; + ans = 64'hC6A0000000007F7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"515583\n"); + end + x = 64'h37A0000020007FFF; + y = 64'h800FF7FFFDFFFFFF; + z = 64'hBF1FFFFA00000000; + ans = 64'hBF1FFFFA00000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"517597\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'h401BFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"519611\n"); + end + x = 64'hB937F8E1E5E7C624; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hC0207FFFFFFFFFFC; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"521625\n"); + end + x = 64'hC012751F6F8812B9; + y = 64'h41D0000000003FFE; + z = 64'h7FFFFFFBFFFFFFEE; + ans = 64'h7FFFFFFBFFFFFFEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"523639\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"525653\n"); + end + x = 64'h31F000000000FFEE; + y = 64'h8010000000000001; + z = 64'hBFC0001FFFFFFFBF; + ans = 64'hBFC0001FFFFFFFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"527667\n"); + end + x = 64'h4713EE08A1624B47; + y = 64'h42DDFFFE00000000; + z = 64'h47F1FFFFFFFFFFEE; + ans = 64'h4A02AF26D8749C7C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"529681\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -47011,19 +12417,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -47039,12 +12445,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"613999\n"); + $fwrite(fp,"531695\n"); end - xrf = 64'h3CA0000000000000; + x = 64'hBCA010001FFFFFFE; + y = 64'hBFD0000000000001; + z = 64'h480FFE000000000F; + ans = 64'h480FFE000000000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"533709\n"); + end + x = 64'h3ED03FEFFFFFFFFE; + y = 64'hBF1FFBFFF7FFFFFE; + z = 64'h3FD000000000037E; + ans = 64'h3FCFFFFFFEFC287C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"535723\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"537737\n"); + end + x = 64'h3FBF800000001000; + y = 64'hBFF0000000000001; + z = 64'hC1DFFFFF7FFF7FFF; + ans = 64'hC1DFFFFF80075FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"539751\n"); + end + x = 64'hC02C219606615D02; + y = 64'h40D0000001FDFFFE; + z = 64'hBFB0002800000000; + ans = 64'hC10C219689E34B8D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"541765\n"); + end + x = 64'h001FFFFFFFFFFFFE; y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h43F001FFC0000000; - ans = 64'h43F001FFC0000000; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; rn = 1; rz = 0; rm = 0; @@ -47058,19 +12699,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -47086,59 +12727,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"614613\n"); + $fwrite(fp,"543779\n"); end - xrf = 64'hFFD0809EC4FE2D71; - y = 64'hBFA4C050535BFCCB; - zrf = 64'h4427ED571629ABB8; - ans = 64'h7F856720C08D93C5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"615227\n"); - end - xrf = 64'h47FFFFFFFFFF8400; + x = 64'hC0000000007FFFF6; y = 64'hC010000000000000; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'hC81FFFFFFFFF8400; + z = 64'hC04FFFFFEFFFFFFF; + ans = 64'hC04BFFFFEFE00002; rn = 1; rz = 0; rm = 0; @@ -47152,19 +12746,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -47180,12 +12774,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"615841\n"); + $fwrite(fp,"545793\n"); end - xrf = 64'h3CA0000000000000; - y = 64'hC3FFBFFFFFFFFFFF; - zrf = 64'h419FC00000000040; - ans = 64'h419FBFC080000040; + x = 64'h3000000000060000; + y = 64'h8027427682235497; + z = 64'hC0EFFFC000FFFFFF; + ans = 64'hC0EFFFC000FFFFFF; rn = 1; rz = 0; rm = 0; @@ -47199,19 +12793,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -47227,12 +12821,1563 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"616455\n"); + $fwrite(fp,"547807\n"); end - xrf = 64'h3FC412D60269F292; + x = 64'h001FFFFFFFFFFFFE; + y = 64'hC340000000000001; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"549821\n"); + end + x = 64'hC34FFFFFFF0000FF; + y = 64'hFFE0000000000000; + z = 64'h3FE00AB9CB1DBB7F; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"551835\n"); + end + x = 64'h401FFFBFFFFFFFFC; + y = 64'hC0000000000100FF; + z = 64'h3FDB0C7F1AA6DCB7; + ans = 64'hC02F275C072CCB10; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"553849\n"); + end + x = 64'h001FFFFFFFFFFFFE; + y = 64'hFFF0000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"555863\n"); + end + x = 64'h3F9FE007FFFFFFFF; + y = 64'h0000000000000000; + z = 64'h420FFFFFE0000800; + ans = 64'h420FFFFFE0000800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"557877\n"); + end + x = 64'h3FE2D582A960D8AF; + y = 64'hBC0FF8FEBC1E5412; + z = 64'hC310000401FFFFFF; + ans = 64'hC310000401FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"559891\n"); + end + x = 64'h3CA0000000000000; + y = 64'h0010000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"561905\n"); + end + x = 64'hBDA000000001FF7F; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h41C0003FFFFFFFFE; + ans = 64'h41C0003FFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"563919\n"); + end + x = 64'hBFE001C000000000; + y = 64'hC3D00000FFBFFFFE; + z = 64'h8001000007FFFFFE; + ans = 64'h43C001C0FFDBF8FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"565933\n"); + end + x = 64'h3CA0000000000000; + y = 64'h3FD0000000000000; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"567947\n"); + end + x = 64'hC1D14111A4841268; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h480100000003FFFE; + ans = 64'h480100000003FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"569961\n"); + end + x = 64'h409FF7FFFFFFF7FF; + y = 64'hBF836AC78348EB47; + z = 64'hBFC2000007FFFFFF; + ans = 64'hC03389ECD1781431; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"571975\n"); + end + x = 64'h3CA0000000000000; + y = 64'h3FF0000000000000; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"573989\n"); + end + x = 64'h47E000004007FFFF; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h8016D5FA0A20E196; + ans = 64'h47F000004007FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"576003\n"); + end + x = 64'hC345DA03C17A0BF0; + y = 64'hEBAFE07FFFFFFFFF; + z = 64'h3E8FFFFFDC000000; + ans = 64'h6F05C48125C797CC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"578017\n"); + end + x = 64'h3CA0000000000000; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"580031\n"); + end + x = 64'h3FD03FFFFFFFFFFC; + y = 64'h401FFFFFFFFFFFFF; + z = 64'hB9BFFFE100000000; + ans = 64'h40003FFFFFFFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"582045\n"); + end + x = 64'h381FFFFFE01FFFFF; + y = 64'hC34FFFFF007FFFFF; + z = 64'hBFBBFFF7FFFFFFFF; + ans = 64'hBFBBFFF7FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"584059\n"); + end + x = 64'h3CA0000000000000; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h3FFFFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"586073\n"); + end + x = 64'h411000FFF7FFFFFE; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'hBFD1FFFC00000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"588087\n"); + end + x = 64'h3CA8C3076307D67C; + y = 64'h37FFFFFFFFFFFF5F; + z = 64'hFFFFFFFFE0000008; + ans = 64'hFFFFFFFFE0000008; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"590101\n"); + end + x = 64'h3CA0000000000000; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"592115\n"); + end + x = 64'hC1C0008007FFFFFF; + y = 64'h8000000000000001; + z = 64'hC6B4F3502E84A07B; + ans = 64'hC6B4F3502E84A07B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"594129\n"); + end + x = 64'hC1D45D281AA37A03; + y = 64'h3C80DFFFFFFFFFFF; + z = 64'h3FE080000000FFFE; + ans = 64'h3FE07FFFEA86BFB2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"596143\n"); + end + x = 64'h3CA0000000000000; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"598157\n"); + end + x = 64'hC16C70639E2CF0BA; + y = 64'hBCA0000000000001; + z = 64'h2100003FFFFFFFFB; + ans = 64'h3E1C70639E2CF0BC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"600171\n"); + end + x = 64'hAE40000101FFFFFF; + y = 64'h47EFFFFF8007FFFF; + z = 64'h001D5692792CE747; + ans = 64'hB6400000C203FBF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"602185\n"); + end + x = 64'h3CA0000000000000; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"604199\n"); + end + x = 64'h0020000000800100; + y = 64'hBFE0000000000001; + z = 64'h3F0FFFFF80FFFFFE; + ans = 64'h3F0FFFFF80FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"606213\n"); + end + x = 64'h41E27AFC7F681471; + y = 64'hC1900000017FFFFF; + z = 64'hBFDFFFFFFC000007; + ans = 64'hC3827AFC81239C1C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"608227\n"); + end + x = 64'h3CA0000000000000; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h0000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"610241\n"); + end + x = 64'hBFD0000120000000; + y = 64'hC000000000000000; + z = 64'h3FC00003FF7FFFFF; + ans = 64'h3FE400021FE00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"612255\n"); + end + x = 64'h428821EC16CB5777; + y = 64'hA0DFFF7FFFFFFBFE; + z = 64'h402E008000000000; + ans = 64'h402E008000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"614269\n"); + end + x = 64'h3CA0000000000000; y = 64'hC010000000000001; - zrf = 64'hC1E476A2F395D532; - ans = 64'hC1E476A2F3A9E808; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000003; rn = 1; rz = 0; rm = 0; @@ -47246,19 +14391,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -47274,12 +14419,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"617069\n"); + $fwrite(fp,"616283\n"); end - xrf = 64'h3CA0000000000000; - y = 64'hC03836C73E52BECA; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hBCEA36C73E52BECA; + x = 64'h3CAF8000001FFFFF; + y = 64'hC340000000000000; + z = 64'h3FDFFFFFDFFEFFFF; + ans = 64'hBFF7800008203FFF; rn = 1; rz = 0; rm = 0; @@ -47293,66 +14438,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"617683\n"); - end - xrf = 64'hC1FFFEFFFFFFFF00; - y = 64'hD1540000000FFFFF; - zrf = 64'hC1FF6A7F749999AB; - ans = 64'h5363FF60000FFEDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -47370,10 +14468,10 @@ initial if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); $fwrite(fp,"618297\n"); end - xrf = 64'h3CA0000000000000; - y = 64'hC340000000000000; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'hBFE0000000000001; + x = 64'hC3FFFFFFFFF007FE; + y = 64'hC1C650B9AA81629A; + z = 64'h381000000000000E; + ans = 64'h45D650B9AA763FD0; rn = 1; rz = 0; rm = 0; @@ -47387,19 +14485,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -47415,5557 +14513,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"618911\n"); + $fwrite(fp,"620311\n"); end - xrf = 64'h3FD78110F038153D; - y = 64'h682FFFE000008000; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"619525\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'hC340000000000001; - zrf = 64'hC2BFFFFFFFFC07FE; - ans = 64'hC2BFFFFFFFFC08FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"620139\n"); - end - xrf = 64'h410002007FFFFFFE; - y = 64'h41801EFFFFFFFFFF; - zrf = 64'hC3FCB59067D08B65; - ans = 64'hC3FCB590274C79E1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"620753\n"); - end - xrf = 64'hC3DFFFFFEFFFFFF6; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h4000000000000000; - ans = 64'h473FFFFFEFFFFFF4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"621367\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'hBE9FFFFFFC03FFFF; - zrf = 64'h7FF00002000003FF; - ans = 64'h7FF80002000003FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"621981\n"); - end - xrf = 64'h41F0000040000FFF; - y = 64'hFFE0000000000000; - zrf = 64'h37E00000FFDFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"622595\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'hECB7B942F9055E17; - zrf = 64'hBCA0000000000000; - ans = 64'hE967B942F9055E17; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"623209\n"); - end - xrf = 64'hBFBFFFFFBFFFFBFE; - y = 64'h403FF80000000FFF; - zrf = 64'hB7EFFC0000000800; - ans = 64'hC00FF7FFC0100BFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"623823\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h3FD0000000000000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"624437\n"); - end - xrf = 64'h3CAFFFFFFFFFBC00; - y = 64'hC0DFFF7FFFFFFFF7; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"625051\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'hFFF0000000000000; - zrf = 64'h3D696CE5B4272424; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"625665\n"); - end - xrf = 64'hB789E111956BE9EB; - y = 64'hFA7FFDFFFFFBFFFF; - zrf = 64'h37B0085F71B84DC0; - ans = 64'h7219DF73844F5709; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"626279\n"); - end - xrf = 64'hC007C6480B50CE31; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"626893\n"); - end - xrf = 64'h3CA0000000000000; - y = 64'h40E0001FF7FFFFFF; - zrf = 64'hB7FD3409DC18DB9B; - ans = 64'h3D90001FF7FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"627507\n"); - end - xrf = 64'hB6B00000000023FF; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h381FFFFFFE000000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"628121\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hBFCC0DA6851DE8E0; - zrf = 64'h8010000000000001; - ans = 64'hBC7C0DA6851DE8E2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"628735\n"); - end - xrf = 64'h2CFFFFFFBBFFFFFF; - y = 64'hC03FFFFFFFFDFFFB; - zrf = 64'hC0E07FFF00000000; - ans = 64'hC0E07FFF00000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"629349\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h3CA0000000000001; - ans = 64'h3CA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"629963\n"); - end - xrf = 64'hC281AA5C3F9C8D6D; - y = 64'h480FFFFFC007FFFE; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hCAA1AA5C1C4C3F84; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"630577\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h001E0000001FFFFF; - ans = 64'h001E0000001FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"631191\n"); - end - xrf = 64'h7FFFFFFFFFFFFF76; - y = 64'h37E4A237FD281C2D; - zrf = 64'h37E0004000FFFFFF; - ans = 64'h7FFFFFFFFFFFFF76; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"631805\n"); - end - xrf = 64'hCCDD9073C4CA0F6E; - y = 64'h0010000000000001; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"632419\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h4030007BFFFFFFFE; - zrf = 64'h00200040003FFFFE; - ans = 64'h3CE0007BFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"633033\n"); - end - xrf = 64'h45D001FFFFFF0000; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h00240000007FFFFF; - ans = 64'h060001FFFFFEFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"633647\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hB0F1000000FFFFFF; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'hADA1000001000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"634261\n"); - end - xrf = 64'h40C0200000000003; - y = 64'h3E9173C34A679357; - zrf = 64'hFFF1FFF7FFFFFFFE; - ans = 64'hFFF9FFF7FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"634875\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h3CA0000000000001; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h3950000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"635489\n"); - end - xrf = 64'hBB5FDFFFFFF7FFFE; - y = 64'h8021FEFFFFFFFFFF; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"636103\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h401FFFFFFEDFFFFF; - ans = 64'h401FFFFFFEDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"636717\n"); - end - xrf = 64'h402FFFFFFFFDDFFE; - y = 64'h3F8FFFFFFFFF000F; - zrf = 64'h406FFBFFFFDFFFFF; - ans = 64'h407001FFFFEFFF9C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"637331\n"); - end - xrf = 64'h41F0060000000000; - y = 64'h3FD0000000000000; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h41D0060000200000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"637945\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hBF30004000200000; - zrf = 64'h16F1FFFFFFFBFFFF; - ans = 64'hBBE0004000200001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"638559\n"); - end - xrf = 64'hC00FBEFFFFFFFFFF; - y = 64'h3FD0000000000001; - zrf = 64'hC1E1FFFFFFFFF7FE; - ans = 64'hC1E20000001FB6FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"639173\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h45EE000000000010; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"639787\n"); - end - xrf = 64'h3CAF000000010000; - y = 64'h40CD9821F2214351; - zrf = 64'h3FEBFFFFFFFFFE00; - ans = 64'h3FEC0000000070AE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"640401\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h3FE0000000000000; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h3C90000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"641015\n"); - end - xrf = 64'hC11FFFF800007FFF; - y = 64'h4342C5257254E48E; - zrf = 64'hC010000000000000; - ans = 64'hC472C520C10BD30D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"641629\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h3FE0000000000001; - zrf = 64'hC02F53C96958BA00; - ans = 64'hC02F53C96958BA00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"642243\n"); - end - xrf = 64'hC3FFFFFFFC1FFFFF; - y = 64'h480FFFFFF8008000; - zrf = 64'hBDE00008007FFFFF; - ans = 64'hCC1FFFFFF4208000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"642857\n"); - end - xrf = 64'hB8020CD4671337DF; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h3FD0000000000000; - ans = 64'h3FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"643471\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h432000000FEFFFFF; - zrf = 64'h43F0001BFFFFFFFF; - ans = 64'h43F0001BFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"644085\n"); - end - xrf = 64'hBFFDB0D21ABE9560; - y = 64'h3FF0000000000000; - zrf = 64'hB808F2DEE31A0781; - ans = 64'hBFFDB0D21ABE9560; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"644699\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h3E295BE2AB58A5F9; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"645313\n"); - end - xrf = 64'hFCC00000040FFFFF; - y = 64'hC3E0A8C598700473; - zrf = 64'hFFE000001FBFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"645927\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h0000000000000000; - ans = 64'h3CB0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"646541\n"); - end - xrf = 64'h001FFFFFFFFFFFE2; - y = 64'hC1FFC000000000FE; - zrf = 64'hC000000000000001; - ans = 64'hC000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"647155\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h4000000000000000; - zrf = 64'h3FDFEFFFFC000000; - ans = 64'h3FDFEFFFFC000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"647769\n"); - end - xrf = 64'hC3FFFFFFEFFFFFFB; - y = 64'h80200007FFFBFFFF; - zrf = 64'h41D01FFFFFE00000; - ans = 64'h41D01FFFFFE00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"648383\n"); - end - xrf = 64'hC0300081FFFFFFFF; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h3CA0000000000001; - ans = 64'hC0500081FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"648997\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hBFE000000FFFDFFF; - zrf = 64'h3FEE60AF9E2E4B00; - ans = 64'h3FEE60AF9E2E4AFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"649611\n"); - end - xrf = 64'hBFDFFFFFFFCFFFFF; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h002FFFFFF7FFFFFF; - ans = 64'hBFFFFFFFFFCFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"650225\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h61BFE01FFFFFFFFF; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"650839\n"); - end - xrf = 64'h44820F5D13A0271D; - y = 64'hC34FFFEFFFFBFFFF; - zrf = 64'hC3E0000FFFE00000; - ans = 64'hC7E20F540BEF5B61; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"651453\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h4010000000000001; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"652067\n"); - end - xrf = 64'hC01B78321869F7BE; - y = 64'hBFCFFFFFF6FFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFD21F37BD3F5963; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"652681\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h57A0008000000400; - ans = 64'h57A0008000000400; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"653295\n"); - end - xrf = 64'h47F0FFFFFFFFFFFE; - y = 64'hBFCFF00000800000; - zrf = 64'hC0800000201FFFFF; - ans = 64'hC7D0F7800043FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"653909\n"); - end - xrf = 64'h000FFFFFFFFFFFF0; - y = 64'h4340000000000001; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h035FFFFFFFFFFFE4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"654523\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h7FD5CF6583F3D781; - zrf = 64'hC03FFFFFFFFBFFFE; - ans = 64'h7C85CF6583F3D782; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"655137\n"); - end - xrf = 64'hBFC0000004000007; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'hC3CFFFDFFFBFFFFE; - ans = 64'hC3D001EFFFE07FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"655751\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hFE303FFFF7FFFFFF; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'hFAE03FFFF8000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"656365\n"); - end - xrf = 64'h4010000220000000; - y = 64'h4F1000010000000E; - zrf = 64'h41D0000000200FFF; - ans = 64'h4F3000032000220E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"656979\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h7FE0000000000000; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"657593\n"); - end - xrf = 64'h37E6C14F3ECC26DC; - y = 64'h000FFFFFFFF0007E; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hBFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"658207\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h4013F2A6D8BFBBDB; - ans = 64'h7CA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"658821\n"); - end - xrf = 64'h47F66E124896F602; - y = 64'h43FFFCFFFFFFFFFF; - zrf = 64'hC02C17F8E33324F9; - ans = 64'h4C066BF7F6E027DA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"659435\n"); - end - xrf = 64'hC696F52476AFBCC8; - y = 64'h7FF0000000000000; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"660049\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hC1CFFE0000400000; - zrf = 64'h483FFFC00007FFFF; - ans = 64'h483FFFC00007FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"660663\n"); - end - xrf = 64'hC7E00002000007FF; - y = 64'h7FF0000000000001; - zrf = 64'hC7EFE000003FFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"661277\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hCB5FFFFDF7FFFFFE; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'hC80FFFFDF8000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"661891\n"); - end - xrf = 64'hC1E00800000007FF; - y = 64'h000FFFFFFFF00020; - zrf = 64'hBE8FFFFFFFFFFFDA; - ans = 64'hBE8FFFFFFFFFFFDA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"662505\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"663119\n"); - end - xrf = 64'h41E000FFFE000000; - y = 64'hBFF0000100000100; - zrf = 64'hBFE0000000000000; - ans = 64'hC1E00100FE2000E0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"663733\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h8000000000000001; - zrf = 64'h4030A513CDCFDE22; - ans = 64'h4030A513CDCFDE22; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"664347\n"); - end - xrf = 64'hBF90A893B7D37E1B; - y = 64'hC00460035561ED96; - zrf = 64'hE6CEFFFFFFFFFFFE; - ans = 64'hE6CEFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"664961\n"); - end - xrf = 64'h3BEFE000FFFFFFFF; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h0000000000000000; - ans = 64'h8000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"665575\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hC1F6C8E803D2458C; - zrf = 64'h43F00000000080FE; - ans = 64'h43F00000000080FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"666189\n"); - end - xrf = 64'h3F6FFFF00FFFFFFF; - y = 64'h8010000000000000; - zrf = 64'h3F9000000000000F; - ans = 64'h3F9000000000000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"666803\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hC120000000200040; - zrf = 64'h4010000000000000; - ans = 64'h400FFFFFFFFE0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"667417\n"); - end - xrf = 64'h3FC00010000000FE; - y = 64'hBB800000000100FF; - zrf = 64'hC80FC00001FFFFFF; - ans = 64'hC80FC00001FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"668031\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"668645\n"); - end - xrf = 64'hC7EF2E0B46A61E7E; - y = 64'hBFFFFF80000007FF; - zrf = 64'hBFD0000000000001; - ans = 64'h47FF2D8E8E790BB0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"669259\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hBCA0000000000000; - zrf = 64'h3801FFFFFFDFFFFE; - ans = 64'hB94FFFFEE0000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"669873\n"); - end - xrf = 64'hFFD00000000001FF; - y = 64'h352FFF7C00000000; - zrf = 64'hBC7FFDF000000000; - ans = 64'hF50FFF7C000003FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"670487\n"); - end - xrf = 64'h37E04000000003FE; - y = 64'hBCA0000000000001; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"671101\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hB80D3E094BC16B46; - zrf = 64'hC7FC72513751EFEA; - ans = 64'hC7FC72513751EFEA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"671715\n"); - end - xrf = 64'h3FA0001400000000; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hBF23FBFFFFFFFFFE; - ans = 64'hBF23FC00000000FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"672329\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hB8010000007FFFFF; - zrf = 64'h4000000000000001; - ans = 64'h4000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"672943\n"); - end - xrf = 64'h7FE00000FFFFFFEE; - y = 64'hC00FFFFFFFFFFF76; - zrf = 64'h47E80CB0EEBCEF16; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"673557\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hBFD0000000000001; - zrf = 64'hC010000000000001; - ans = 64'hC010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"674171\n"); - end - xrf = 64'hC520008000020000; - y = 64'h3FBFFFFFFDFFFFFC; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC4F0007FFF01F7FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"674785\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h38113D51639121A9; - ans = 64'hBC90000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"675399\n"); - end - xrf = 64'hFFFFFFFBEFFFFFFE; - y = 64'hC3FF564D15AB56DC; - zrf = 64'h56BF000000000003; - ans = 64'hFFFFFFFBEFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"676013\n"); - end - xrf = 64'h4035C1F65B378519; - y = 64'hBFE0000000000000; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"676627\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hBA2FDFFFFFFDFFFF; - zrf = 64'h402FFFFFFFFFE1FF; - ans = 64'h402FFFFFFFFFE1FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"677241\n"); - end - xrf = 64'h401C000001FFFFFF; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hC34C792259BDA2BF; - ans = 64'hC34C792259BDA2C3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"677855\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hFFF0000000006000; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'hFFF8000000006000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"678469\n"); - end - xrf = 64'h47FFFFF80000007F; - y = 64'h3A1BDFDA2C46A1D6; - zrf = 64'h46EFFFFFFFFFE07F; - ans = 64'h46EFFFFFFFFFE07F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"679083\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hBFF0000000000000; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"679697\n"); - end - xrf = 64'h44F0000000000DFF; - y = 64'h000000007FBFFFFE; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h03BFEFFFFF801BF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"680311\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h3FF0007FFFFFFC00; - ans = 64'h3FF0007FFFFFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"680925\n"); - end - xrf = 64'hC000000000000000; - y = 64'hC010000100001FFE; - zrf = 64'h405157A7B0E2BCA9; - ans = 64'h405357A7D0E2C0A9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"681539\n"); - end - xrf = 64'h44D400000007FFFF; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC4E400000807FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"682153\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hFFF0000000001FFD; - zrf = 64'hC1E000080000003F; - ans = 64'hFFF8000000001FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"682767\n"); - end - xrf = 64'h4BD00003FFDFFFFE; - y = 64'hC000000000000001; - zrf = 64'hD4CFFFFFFFFFFC02; - ans = 64'hD4CFFFFFFFFFFC02; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"683381\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hC19000002000007F; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h3FEFFFFFFBFFFFF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"683995\n"); - end - xrf = 64'hBCAFFEFEFFFFFFFE; - y = 64'h41DFFFFFF800001E; - zrf = 64'hFFDFFFFFEFFFFF80; - ans = 64'hFFDFFFFFEFFFFF80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"684609\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"685223\n"); - end - xrf = 64'hC1EE000000000020; - y = 64'h3FD000000007BFFF; - zrf = 64'h8010000000000000; - ans = 64'hC1CE0000000E881E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"685837\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hC010000000000001; - zrf = 64'h87A0100000001FFE; - ans = 64'hBCC0000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"686451\n"); - end - xrf = 64'h4377FFFFFBFFFFFE; - y = 64'hBFDCFFFFFFFFFFFE; - zrf = 64'h4003FFF7FFFFFFFF; - ans = 64'hC365BFFFFC5FFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"687065\n"); - end - xrf = 64'h8E89B3D545ADB9EA; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"687679\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hBFB00000000200FF; - zrf = 64'hBE37FFFFFFFFFFDF; - ans = 64'hBE380000007FFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"688293\n"); - end - xrf = 64'h47F940B6FC43B061; - y = 64'hC340000000000000; - zrf = 64'hF56FFFFB7FFFFFFF; - ans = 64'hF56FFFFB7FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"688907\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hC00FFFFFFFFFFF02; - zrf = 64'h3FE0000000000000; - ans = 64'h3FDFFFFFFFFFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"689521\n"); - end - xrf = 64'h43E0000000080007; - y = 64'h43E1000040000000; - zrf = 64'h381FFFFFFFFF83FE; - ans = 64'h47D1000040088008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"690135\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hBFF0000000000000; - ans = 64'hC008000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"690749\n"); - end - xrf = 64'hEE0000000000037F; - y = 64'h40ABFFFFF7FFFFFF; - zrf = 64'h8000000000000001; - ans = 64'hEEBBFFFFF800061D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"691363\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hFFE0000000000000; - zrf = 64'hC0BFFFF7FFFFFFF6; + x = 64'h3CA0000000000000; + y = 64'hFFE0000000000001; + z = 64'h4340000000000000; ans = 64'hFC90000000000001; rn = 1; rz = 0; @@ -52980,19 +14532,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -53008,153 +14560,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"691977\n"); + $fwrite(fp,"622325\n"); end - xrf = 64'h3EB001FFFFFFFFFE; - y = 64'hBFB00010000FFFFE; - zrf = 64'h802A8ECA25EFF308; - ans = 64'hBE700210021001FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"692591\n"); - end - xrf = 64'h41600801FFFFFFFF; - y = 64'hFFE0000000000001; - zrf = 64'hC010000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"693205\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hACDFFFFFFFFF7EFF; - zrf = 64'h3FA0000000000200; - ans = 64'h3FA0000000000200; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"693819\n"); - end - xrf = 64'hC7FFFFFFC00003FE; + x = 64'hBE01000000100000; y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'hBFBFFFE000001FFE; - ans = 64'h7FF0000000000000; + z = 64'hBFD79D33FB7309A1; + ans = 64'h7E010000000FFFFF; rn = 1; rz = 0; rm = 0; @@ -53168,19 +14579,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -53196,12 +14607,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"694433\n"); + $fwrite(fp,"624339\n"); end - xrf = 64'h3CA0000000000001; - y = 64'hC470000020000000; - zrf = 64'h3FD0000000000001; - ans = 64'hC11FFFFF40000002; + x = 64'hC01000007FFFFFDE; + y = 64'h3811953D5A433174; + z = 64'h3E7FFDFFFF7FFFFF; + ans = 64'h3E7FFDFFFF7FFFFF; rn = 1; rz = 0; rm = 0; @@ -53215,19 +14626,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -53243,152 +14654,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"695047\n"); + $fwrite(fp,"626353\n"); end - xrf = 64'hC056EDE19622E177; - y = 64'hBEC003FFEFFFFFFF; - zrf = 64'hC03FF7FFFFF7FFFF; - ans = 64'hC03FF7F486298432; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"695661\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hFFF0000000000001; - zrf = 64'hBFE0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"696275\n"); - end - xrf = 64'hC80F000000001FFF; - y = 64'h458088C216B51E42; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"696889\n"); - end - xrf = 64'h3CA0000000000001; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'hBAFFFFE000003FFF; + x = 64'h3CA0000000000001; + y = 64'h0000000000000000; + z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -53403,19 +14673,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -53431,5558 +14701,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"697503\n"); + $fwrite(fp,"628367\n"); end - xrf = 64'h3F9FFFFFFC07FFFE; - y = 64'h43FEA1961EA52621; - zrf = 64'hAA7DFFFFFFFDFFFF; - ans = 64'h43AEA1961AD89BC1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"698117\n"); - end - xrf = 64'h3FDBC2FC6A07DACB; - y = 64'h0000000000000000; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"698731\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h41E0001000000000; - zrf = 64'h37F0000000BFFFFF; - ans = 64'h3EA0000FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"699345\n"); - end - xrf = 64'h480007FFFFFFF7FF; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h3EBFEFFC00000000; - ans = 64'h3EBFEFFC00000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"699959\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hB81000007FFFFFFE; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"700573\n"); - end - xrf = 64'h41E1FFFFFF7FFFFE; - y = 64'hB81207FFFFFFFFFF; - zrf = 64'hAD7000080007FFFF; - ans = 64'hBA0448FFFF6FBFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"701187\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h0010000000000000; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"701801\n"); - end - xrf = 64'hC01FFDFFFFFE0000; - y = 64'h3FC0008000003FFF; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"702415\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hAA100008003FFFFF; - ans = 64'hAA100008003FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"703029\n"); - end - xrf = 64'hC349DB908A4890C2; - y = 64'hC3CFFFFFFC07FFFF; - zrf = 64'hC3F000FFFF7FFFFF; - ans = 64'h4729DB9087139592; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"703643\n"); - end - xrf = 64'hC1D00000803FFFFF; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hBFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"704257\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h357AA218DB1B86F0; - zrf = 64'hC04A768475032095; - ans = 64'hC04A768475032095; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"704871\n"); - end - xrf = 64'hCB6C57A1E8AE7848; - y = 64'h3CA0000000000001; - zrf = 64'h440FF00000000200; - ans = 64'hC81C57A1E8AE784A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"705485\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hD1112CAD3B4C5218; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'hCDD12CAD3B4C5217; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"706099\n"); - end - xrf = 64'h41CFC00400000000; - y = 64'h40FFFFFF81FFFFFF; - zrf = 64'h532FFFFFFFFDDFFE; - ans = 64'h532FFFFFFFFDDFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"706713\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hBCAFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"707327\n"); - end - xrf = 64'h800001FBFFFFFFFF; - y = 64'h252000000000203F; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"707941\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h3FD0000000000001; - zrf = 64'hBF4200000001FFFF; - ans = 64'hBF4200000001FDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"708555\n"); - end - xrf = 64'h43E3D73EF74F964F; - y = 64'hD51FFFE0000003FE; - zrf = 64'hC0311B57B645A4AC; - ans = 64'hD913D72B2010A179; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"709169\n"); - end - xrf = 64'hC3CFFFFFEFFFFFFA; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hBFF0000000000000; - ans = 64'hC3BFFFFFEFFFFFF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"709783\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h7FFFD9879D865521; - zrf = 64'hBCAE2425EBD33EF3; - ans = 64'h7FFFD9879D865521; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"710397\n"); - end - xrf = 64'hC801212E737DEEDD; - y = 64'h3FE0000000000000; - zrf = 64'hC1E000000002FFFF; - ans = 64'hC7F1212E737DEEDD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"711011\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h43EFE00000000FFF; - zrf = 64'h0010000000000000; - ans = 64'h40AFE00000000FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"711625\n"); - end - xrf = 64'hC7F00FFFFFFFFFDF; - y = 64'h06AAB018F1034A95; - zrf = 64'h426FFFFFFE003FFE; - ans = 64'h426FFFFFFE003FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"712239\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'hBCA0000000000000; - ans = 64'h3C9FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"712853\n"); - end - xrf = 64'hFFD4BE7F3DBDF4C8; - y = 64'hFFEFFFFFFFFEFC00; - zrf = 64'h4340000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"713467\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h3FF0000000000000; - zrf = 64'hBFCA84F360B6B606; - ans = 64'hBFCA84F360B6B5FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"714081\n"); - end - xrf = 64'h4035891D30C0B3AA; - y = 64'hC341021685229DA4; - zrf = 64'h800FFFFFC0007FFF; - ans = 64'hC386E47E772D5436; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"714695\n"); - end - xrf = 64'h2D3FFFFFFFC1FFFE; - y = 64'h3FF0000000000001; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"715309\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h434FFFFFFFFEFF00; - zrf = 64'hC7FFFBFFFFFF7FFF; - ans = 64'hC7FFFBFFFFFF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"715923\n"); - end - xrf = 64'h3FCFFFFFFFFCFFFE; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h9C300000008000FF; - ans = 64'h3FDFFFFFFFFCFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"716537\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hC3E87114AD0D0CDC; - zrf = 64'h0000000000000001; - ans = 64'hC0A87114AD0D0CDB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"717151\n"); - end - xrf = 64'h3E00027FFFFFFFFF; - y = 64'h3CAE000020000000; - zrf = 64'hBCA2000000000080; - ans = 64'hBCA1FFFFFFC3F720; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"717765\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h4000000000000001; - zrf = 64'h8010000000000001; - ans = 64'h3CC0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"718379\n"); - end - xrf = 64'h3D780000000003FF; - y = 64'hBF60000003FFFFFE; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h401FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"718993\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hA90BB2526EA06D43; - ans = 64'h3CCFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"719607\n"); - end - xrf = 64'h43EFFEF7FFFFFFFF; - y = 64'hFFDFFFFFFEFFDFFF; - zrf = 64'h3FD00DFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"720221\n"); - end - xrf = 64'hC011D00DCFE601AD; - y = 64'h4010000000000000; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hC032500DCFE601AD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"720835\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h40300000040003FE; - zrf = 64'hFFF0000000000042; - ans = 64'hFFF8000000000042; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"721449\n"); - end - xrf = 64'hFFFFFFFE00001FFF; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hFFE553153A57374C; - ans = 64'hFFFFFFFE00001FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"722063\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h3FE0300000000000; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"722677\n"); - end - xrf = 64'h43CFFFFBFFF7FFFF; - y = 64'h3CA0000001000007; - zrf = 64'h3E5FFFFFFFFFE001; - ans = 64'h407FFFFC01FFFFCD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"723291\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h4340000000000000; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"723905\n"); - end - xrf = 64'h3810007FFFE00000; - y = 64'hBFEFFC0000000FFE; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"724519\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h4010000003DFFFFE; - ans = 64'h4020000001EFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"725133\n"); - end - xrf = 64'h45BFE04000000000; - y = 64'hBFD0000002000003; - zrf = 64'h3220000000000200; - ans = 64'hC59FE04003FC0806; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"725747\n"); - end - xrf = 64'h3EF1000000000FFF; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'h4251000000000FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"726361\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFEC0; - zrf = 64'h41E002007FFFFFFF; - ans = 64'h41E002007FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"726975\n"); - end - xrf = 64'h3CA9C1833ECE31D2; - y = 64'h7FE0000000000001; - zrf = 64'h400000001FFFFFFF; - ans = 64'h7C99C1833ECE31D4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"727589\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hC050000103FFFFFE; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"728203\n"); - end - xrf = 64'hBF40040000000003; - y = 64'h407000000000080F; - zrf = 64'hC0100000010007FF; - ans = 64'hC010802001000840; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"728817\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"729431\n"); - end - xrf = 64'hCF30000002001FFF; - y = 64'hC3ED50F16BE304A9; - zrf = 64'h4000000000000000; - ans = 64'h532D50F16F8D5D77; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"730045\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h7FF0000000000001; - zrf = 64'h47E0000000090000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"730659\n"); - end - xrf = 64'h3FEFFFFFFFDFFFDF; - y = 64'hB80FFFF7FFFFFFFD; - zrf = 64'h492FFFFFFFFDFFFA; - ans = 64'h492FFFFFFFFDFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"731273\n"); - end - xrf = 64'hC010040FFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'hBCA0000000000000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"731887\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hC1E52E6A88527BEA; - zrf = 64'hB8172BF98589A737; - ans = 64'hBEA52E6A88527BE9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"732501\n"); - end - xrf = 64'h382A6081434E0C86; - y = 64'h8000000000000000; - zrf = 64'hC1DE0000000FFFFF; - ans = 64'hC1DE0000000FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"733115\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h480FFFE07FFFFFFF; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"733729\n"); - end - xrf = 64'h3FCFFFFFF8000010; - y = 64'hC3CA813954F8319C; - zrf = 64'h37FFFFFFFEFFFFEE; - ans = 64'hC3AA81394E57E354; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"734343\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"734957\n"); - end - xrf = 64'hC1E2E3C25E069868; - y = 64'hBF38D24613FBB2E4; - zrf = 64'h3FF0000000000001; - ans = 64'h412D4DE5A025F585; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"735571\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h8010000000000000; - zrf = 64'hBA8C582F680D0E8F; - ans = 64'hBA8C582F680D0E8F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"736185\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hB8100000000047FE; - zrf = 64'hBE7477104525BE79; - ans = 64'hBE7477104525BE79; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"736799\n"); - end - xrf = 64'h20C000002000000E; - y = 64'h8010000000000001; - zrf = 64'h8010000000000001; - ans = 64'h8010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"737413\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hC7FFDFFFFFFFFE00; - zrf = 64'hF0B46465EE8EBBB1; - ans = 64'hF0B46465EE8EBBB1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"738027\n"); - end - xrf = 64'h4340000400010000; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'hC7F000007FFFFC00; - ans = 64'hC7F000007FFFFC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"738641\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hB7EFFFFFFFFFFFEE; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"739255\n"); - end - xrf = 64'h4040003FFFFFFFFB; - y = 64'h43EC8C7FBE059B61; - zrf = 64'h434FF80000FFFFFF; - ans = 64'h443C8D31E004956F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"739869\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hBCA0000000000001; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"740483\n"); - end - xrf = 64'hB7EFFFFE0000FFFF; - y = 64'h40503E9D4BC704B0; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"741097\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'hE48FFFFFF7FFFFEE; - ans = 64'hE48FFFFFF7FFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"741711\n"); - end - xrf = 64'h7FDF800001000000; - y = 64'h499BC83FCE25B88B; - zrf = 64'hC02FFFE000000FFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"742325\n"); - end - xrf = 64'hC1E0001FC0000000; - y = 64'hBFD0000000000000; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h41C0001FC0000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"742939\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h3FF03FFFFF7FFFFF; - zrf = 64'hB7ED50191FEBB6C0; - ans = 64'h3CB03FFFFF7FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"743553\n"); - end - xrf = 64'hFFD0000000037FFE; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h434FFAFFFFFFFFFF; - ans = 64'h7FC0000000037FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"744167\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hBF7DFFFF7FFFFFFE; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"744781\n"); - end - xrf = 64'h98D4F4367275AF07; - y = 64'h3FEFF80003FFFFFF; - zrf = 64'h802FFFFC00000007; - ans = 64'h98D4EEF967779869; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"745395\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hBFE0000000000000; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"746009\n"); - end - xrf = 64'h3F9D0C184AFAD181; - y = 64'hFFE001E000000000; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'hFF8D0F7FB5D39AE6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"746623\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hBFE0000000000001; - zrf = 64'h43F03F7FFFFFFFFF; - ans = 64'h43F03F7FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"747237\n"); - end - xrf = 64'h0006BAA6E6628D4B; - y = 64'h3D2FFFF000002000; - zrf = 64'hBFEEFFFFFFFFC000; - ans = 64'hBFEEFFFFFFFFC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"747851\n"); - end - xrf = 64'h3FB002000000FFFF; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"748465\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hB32832CD4DA733A1; - zrf = 64'hB7F0010000100000; - ans = 64'hB7F0010000100000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"749079\n"); - end - xrf = 64'hC3FFFFFF04000000; - y = 64'hBFF0000000000001; - zrf = 64'hBCBFFFFFFFFF0006; - ans = 64'h43FFFFFF04000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"749693\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h41E7FFFFFFFFFFFC; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC00FFFFF9FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"750307\n"); - end - xrf = 64'hA253DCAE002F464A; - y = 64'hE920001000000080; - zrf = 64'h0020000000FEFFFF; - ans = 64'h4B83DCC1DCDD4718; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"750921\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h401FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"751535\n"); - end - xrf = 64'h5750000000000040; - y = 64'h400AB0370585F185; - zrf = 64'h3FD0000000000000; - ans = 64'h576AB0370585F1F0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"752149\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hC000000000000000; - zrf = 64'h3CA2000000000400; - ans = 64'hBCB6FFFFFFFFFDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"752763\n"); - end - xrf = 64'hC10DEB4451CF9086; - y = 64'h4770100000004000; - zrf = 64'hD5EFFFFEFFFFFFDF; - ans = 64'hD5EFFFFEFFFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"753377\n"); - end - xrf = 64'hF0863251E8FE0225; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"753991\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h41F007FFEFFFFFFE; - zrf = 64'h404FFFFFFBFFFFF8; - ans = 64'h405000000201FFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"754605\n"); - end - xrf = 64'h3F8FFFE001FFFFFE; - y = 64'hC010000000000000; - zrf = 64'h3CA0008000000FFF; - ans = 64'hBFAFFFE001FFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"755219\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h37E71F98C279DBBC; - zrf = 64'hC000000000000000; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"755833\n"); - end - xrf = 64'h37E00400001FFFFE; - y = 64'h43F8400F900F53B5; - zrf = 64'hC3EFFFFFBFFFF7FE; - ans = 64'hC3EFFFFFBFFFF7FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"756447\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h4010000000000000; - ans = 64'h400FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"757061\n"); - end - xrf = 64'hBDE1C565EC0236AF; - y = 64'hBCAFFFF000000100; - zrf = 64'h3CA0000000000001; - ans = 64'h3CA000000011C55E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"757675\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hC02CBE486A2B0809; - ans = 64'hC02CBE486A2B080A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"758289\n"); - end - xrf = 64'hBFDFFDFFFBFFFFFF; - y = 64'h3F0F7FFFFFF80000; - zrf = 64'h4D90000000010006; - ans = 64'h4D90000000010006; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"758903\n"); - end - xrf = 64'h28A9110868DC09E4; - y = 64'hC340000000000001; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"759517\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hC02FBFFFFEFFFFFF; - zrf = 64'h4803ABE97F306C7A; - ans = 64'h4803ABE97F306C7A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"760131\n"); - end - xrf = 64'hBFC000000FFFFE00; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h40EBFFFFFEFFFFFF; - ans = 64'h432000001001BDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"760745\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hC7F0000400000003; - zrf = 64'hBFF0000000000001; - ans = 64'hC4B0000400000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"761359\n"); - end - xrf = 64'hBEF2000000001FFE; - y = 64'h41D9A46BD6DA0E6B; - zrf = 64'h001FFFFFEFFFFF7F; - ans = 64'hC0DCD8F951B5837E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"761973\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hFFE0000000000001; - zrf = 64'h4000000000000001; - ans = 64'hFCA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"762587\n"); - end - xrf = 64'h000667C5D67E1D85; - y = 64'h3FDFEFFFFDFFFFFF; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h002199247CCB1886; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"763201\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h43DC000001000000; - ans = 64'hFCAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"763815\n"); - end - xrf = 64'h400FFFFBFFFFEFFF; - y = 64'hC3FFC00000000000; - zrf = 64'h37F007FFFFFFFFBF; - ans = 64'hC41FBFFC07FFF01F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"764429\n"); - end - xrf = 64'hC02DA3D0B1B2F367; - y = 64'hFFF0000000000000; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"765043\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h43CFFFFFFFFFFF0F; - zrf = 64'hC80000FFFFFEFFFF; - ans = 64'hC80000FFFFFEFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"765657\n"); - end - xrf = 64'hBFDFFFFFFFFFFFF3; - y = 64'hFFF0000000000001; - zrf = 64'h3FDFFFFFFFFFF7FB; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"766271\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFF; - y = 64'h41F080FFFFFFFFFF; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFEFFFFDEFDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"766885\n"); - end - xrf = 64'hBEC0080000003FFF; - y = 64'h39300003FFFFFFEF; - zrf = 64'hB80F865401D278F7; - ans = 64'hB817C72C01E95C73; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"767499\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h0000000000000000; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"768113\n"); - end - xrf = 64'h000007FFFFFFFFFE; - y = 64'h3F6FFFFFFE01FFFE; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h00100007FFFFFF7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"768727\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h0000000000000001; - zrf = 64'hC0583D940632C786; - ans = 64'hC0583D940632C786; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"769341\n"); - end - xrf = 64'h7FEFFFFBFFFFFF80; - y = 64'h4026126760B56D8C; - zrf = 64'hD92BBFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"769955\n"); - end - xrf = 64'hC1CFFFE000000040; + x = 64'h381FF7FF7FFFFFFF; y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h401FFFFFFFFFFFFE; + z = 64'h480200000000001F; + ans = 64'h480200000000001F; rn = 1; rz = 0; rm = 0; @@ -58996,19 +14720,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -59024,12 +14748,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"770569\n"); + $fwrite(fp,"630381\n"); end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h4060000001000006; - zrf = 64'h4070001FFFFF7FFE; - ans = 64'h4070001FFFFF7FFF; + x = 64'h3FB0FFFFFFFFFFFF; + y = 64'h407000000FFFFFBF; + z = 64'hC0F00000000800FE; + ans = 64'hC0EFFDE0000DE1FC; rn = 1; rz = 0; rm = 0; @@ -59043,19 +14767,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -59071,247 +14795,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"771183\n"); + $fwrite(fp,"632395\n"); end - xrf = 64'h548FFFFFC00FFFFE; - y = 64'h0010000000000000; - zrf = 64'h817B000000000000; - ans = 64'h14AFFFFFC00FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"771797\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h43C001000001FFFF; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'h407FFA000003FFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"772411\n"); - end - xrf = 64'hC01FF7FFFFFEFFFF; - y = 64'hC3F2000000000FFE; - zrf = 64'h4800007FE0000000; - ans = 64'h4800007FE0000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"773025\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h3FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"773639\n"); - end - xrf = 64'hBFEFFFFFFFDBFFFF; - y = 64'hB7FFFFFFFFF7FFF7; - zrf = 64'h0000000000000000; - ans = 64'h37FFFFFFFFD3FFF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"774253\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; + x = 64'h3CA0000000000001; y = 64'h3CA0000000000000; - zrf = 64'hC49FF7FFFE000000; - ans = 64'hC49FF7FFFE000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -59325,19 +14814,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -59353,153 +14842,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"774867\n"); + $fwrite(fp,"634409\n"); end - xrf = 64'h51E7FFFFFFFFFF7F; - y = 64'h40129211363ADFB4; - zrf = 64'hCB697B092581A9BA; - ans = 64'h520BDB19D1584EF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"775481\n"); - end - xrf = 64'hC074007FFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h4010000000000000; - ans = 64'h400FFFFFFFFFFF60; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"776095\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h48000000000000EF; - zrf = 64'hA20003FFFF800000; - ans = 64'h44C00000000000EE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"776709\n"); - end - xrf = 64'h40B0000000003FF8; + x = 64'hB7FFFF7FFFBFFFFF; y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h438FFEFFFFFFFFDF; - ans = 64'h438FFEFFFFFFFFDF; + z = 64'hC34D14F7E73ECCFF; + ans = 64'hC34D14F7E73ECCFF; rn = 1; rz = 0; rm = 0; @@ -59513,19 +14861,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -59541,12 +14889,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"777323\n"); + $fwrite(fp,"636423\n"); end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hC7F9D14ED895890F; - zrf = 64'hBFD0000000000000; - ans = 64'hC4B9D14ED895890D; + x = 64'hC050000003DFFFFF; + y = 64'hBD6000000004000F; + z = 64'h3FEF7FFFFFFFFFDE; + ans = 64'h3FEF80000003FFDE; rn = 1; rz = 0; rm = 0; @@ -59560,19 +14908,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -59588,33945 +14936,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"777937\n"); + $fwrite(fp,"638437\n"); end - xrf = 64'h801000000007FFFF; - y = 64'hBFD36A9BB1F93547; - zrf = 64'h405000000000006F; - ans = 64'h405000000000006F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"778551\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"779165\n"); - end - xrf = 64'h002FFEF7FFFFFFFF; - y = 64'hC08FFFFE0FFFFFFE; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"779779\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h402FFF801FFFFFFE; - ans = 64'h402FFF801FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"780393\n"); - end - xrf = 64'hBEC02000001FFFFF; - y = 64'hCC5000DFFFFFFFFF; - zrf = 64'hB7F0010000000040; - ans = 64'h4B2020E1C02001BE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"781007\n"); - end - xrf = 64'h3CA000000FFF0000; - y = 64'h3FE0000000000001; - zrf = 64'h4000000000000001; - ans = 64'h4000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"781621\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h403FFFFFBFFFEFFE; - zrf = 64'h37ED46FC2B0023A2; - ans = 64'h3CFFFFFFBFFFEFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"782235\n"); - end - xrf = 64'hB7E9EFD68B497421; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h3E6000000000040E; - ans = 64'h3E6000000000040E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"782849\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h000266016A39E777; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"783463\n"); - end - xrf = 64'h37F95059156CD4C4; - y = 64'hC3F01DFFFFFFFFFF; - zrf = 64'hC7F0002000000004; - ans = 64'hC7F0002000000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"784077\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h3FF0000000000001; - zrf = 64'h3FD0000000000001; - ans = 64'h3FD0000000000005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"784691\n"); - end - xrf = 64'h80070847320BC888; - y = 64'h7CE47DBA0F14EAF5; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"785305\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hB7F4FECA1F205474; - ans = 64'h3CBFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"785919\n"); - end - xrf = 64'hC03FFE001FFFFFFF; - y = 64'hC5DCEA96744E1936; - zrf = 64'h43C0000003EFFFFF; - ans = 64'h462CE8C7E7D1AAC8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"786533\n"); - end - xrf = 64'hBFD7FFFFFFBFFFFF; - y = 64'h4000000000000000; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h3FF4000000200000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"787147\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hC5CE77F1E2F669DB; - zrf = 64'h49C3FFFFFFFDFFFF; - ans = 64'h49C3FFFFFFFDFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"787761\n"); - end - xrf = 64'h3D1FFFFFFFFFFFF5; - y = 64'h4000000000000001; - zrf = 64'h32F000007FFFFFFF; - ans = 64'h3D2FFFFFFFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"788375\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hC3C0FFFFFFFFFFFF; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'hC080FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"788989\n"); - end - xrf = 64'h40D00001FFBFFFFF; - y = 64'h66B7849965C4EBF6; - zrf = 64'hBCC000004000007E; - ans = 64'h6797849C55FA0648; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"789603\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h4010000000000000; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CD3FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"790217\n"); - end - xrf = 64'h761FAA6A41261C23; - y = 64'h477FFF8000000002; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'h7DAFA9EB977D178D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"790831\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h4010000000000001; - zrf = 64'h4039A83A2B1F9F06; - ans = 64'h4039A83A2B1F9F06; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"791445\n"); - end - xrf = 64'h3CAA3DE7B7AA7C1C; - y = 64'h3FEFFFFFFF8001FF; - zrf = 64'h43F00000000DFFFE; - ans = 64'h43F00000000DFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"792059\n"); - end - xrf = 64'h6A9FFFFF07FFFFFF; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h6ACFFFFF07FFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"792673\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h36DBC55BED797727; - zrf = 64'hC10EF56A7E932EFD; - ans = 64'hC10EF56A7E932EFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"793287\n"); - end - xrf = 64'hB809C1DDC84B5E09; - y = 64'h4340000000000000; - zrf = 64'hC72FFDF7FFFFFFFF; - ans = 64'hC72FFDF7FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"793901\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hC51574C4CCC1F217; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hC1D574C4CCC1F216; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"794515\n"); - end - xrf = 64'hC34000007FFFEFFF; - y = 64'hC800000000007FFA; - zrf = 64'hDB9FFFFFFF6FFFFE; - ans = 64'hDB9FFFFFFF6FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"795129\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"795743\n"); - end - xrf = 64'hC02F000003FFFFFF; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"796357\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h7FE0000000000000; - zrf = 64'h3F2FFDFFFFFFFF80; - ans = 64'h7C9FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"796971\n"); - end - xrf = 64'hB7F07FFFFFFFFFFC; - y = 64'h7FDFFFFFFFFF7C00; - zrf = 64'hC03FFFFFC0000003; - ans = 64'hF7E07FFFFFFFBBEC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"797585\n"); - end - xrf = 64'h801FFFFBFEFFFFFE; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h3FE0000000000000; - ans = 64'hC01DFFFBFEFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"798199\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hBFDFEFFFFFFFEFFF; - zrf = 64'h43A0043FFFFFFFFE; - ans = 64'h43A0043FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"798813\n"); - end - xrf = 64'hC017A0FB0E9F66C3; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hFFDFEFFFFFFFFFDE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"799427\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hC01FFFBFBFFFFFFF; - zrf = 64'h8000000000000000; - ans = 64'hBCDFFFBFBFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"800041\n"); - end - xrf = 64'hBFBFFDC000000000; - y = 64'h37F003FFFFFFFEFE; - zrf = 64'hC093287BC3456222; - ans = 64'hC093287BC3456222; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"800655\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h0010000000000000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"801269\n"); - end - xrf = 64'hC060000080000400; - y = 64'hBFD000000100000E; - zrf = 64'hC010000000000001; - ans = 64'h403C00010200082C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"801883\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h41C0000000000FE0; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"802497\n"); - end - xrf = 64'hC7EFC000007FFFFF; - y = 64'h3FBFFFFFFFFFE7FE; - zrf = 64'h3FEBA884A0712B77; - ans = 64'hC7BFC000007FE82D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"803111\n"); - end - xrf = 64'h8022424C23A46355; - y = 64'h8000000000000001; - zrf = 64'h3FD0000000000001; - ans = 64'h3FD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"803725\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hD4DFFFF800800000; - zrf = 64'h401FFC7FFFFFFFFE; - ans = 64'hD19FFFF8007FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"804339\n"); - end - xrf = 64'h3FEA91C55BA6D318; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h38A3B6C3AD39060C; - ans = 64'h38A3B6C3AD39060C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"804953\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hBFDFFFDFFFFFFFF0; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"805567\n"); - end - xrf = 64'h381FDFFFFFFFFC00; - y = 64'h3E400000400FFFFF; - zrf = 64'hC03605C500F49014; - ans = 64'hC03605C500F49014; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"806181\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h8010000000000001; - zrf = 64'h0000000000000001; - ans = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"806795\n"); - end - xrf = 64'hC0E0000000000401; - y = 64'h80100000083FFFFE; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"807409\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h408FFFE0000003FF; - ans = 64'h408FFFE0000003FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"808023\n"); - end - xrf = 64'h3C4000007FFFFFFB; - y = 64'h3FB0020000080000; - zrf = 64'hC11FF7FFFFFFFFF0; - ans = 64'hC11FF7FFFFFFFFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"808637\n"); - end - xrf = 64'hC7E00000000F7FFE; - y = 64'hBCA0000000000000; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h44900000000F7FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"809251\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h3FEFFFFFFFFFFEFC; - zrf = 64'hFFD00000043FFFFF; - ans = 64'hFFD00000043FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"809865\n"); - end - xrf = 64'hC800080000000002; - y = 64'hBCA0000000000001; - zrf = 64'h00000000000000FB; - ans = 64'h44B0080000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"810479\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h47F00000FFBFFFFE; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"811093\n"); - end - xrf = 64'hBFF004000003FFFF; - y = 64'h84F9917D0C96A324; - zrf = 64'hB450100000080000; - ans = 64'hB450100000080000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"811707\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"812321\n"); - end - xrf = 64'h41FFFFFFFEFFFDFF; - y = 64'h0DEFFFFFFF007FFF; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hBFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"812935\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hBFD0000000000001; - zrf = 64'h4030808000000000; - ans = 64'h4030808000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"813549\n"); - end - xrf = 64'hC0300000000003EF; - y = 64'h408FFFBFFFEFFFFF; - zrf = 64'hBDAFFFE01FFFFFFE; - ans = 64'hC0CFFFBFFFF007E5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"814163\n"); - end - xrf = 64'h4173847C57956A54; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'hC163847C57956A53; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"814777\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hFFF0000006000000; - zrf = 64'h377FFFFF80001FFF; - ans = 64'hFFF8000006000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"815391\n"); - end - xrf = 64'h3FEFAFFFFFFFFFFE; - y = 64'hBFE0000000000000; - zrf = 64'h40B000007FFFDFFE; - ans = 64'h40AFFF037FFFBFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"816005\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hC7EFFFFFFFFFEFFF; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'hC4AFFFFF7FFFEFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"816619\n"); - end - xrf = 64'h3F1AF153D63208C5; - y = 64'h41CFEDD90920FE45; - zrf = 64'hC3D0000000000820; - ans = 64'hC3D00000000007B4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"817233\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"817847\n"); - end - xrf = 64'h3FF000010003FFFE; - y = 64'h40D000000DFFFFFF; - zrf = 64'hBFF0000000000000; - ans = 64'h40CFFF821C0801BA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"818461\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hBFF0000000000000; - zrf = 64'hEB9C3D16BF65A760; - ans = 64'hEB9C3D16BF65A760; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"819075\n"); - end - xrf = 64'h4341BC45DB03D622; - y = 64'h480FFFFFFFBFFFFA; - zrf = 64'h80000DFFFFFFFFFE; - ans = 64'h4B61BC45DAE05D93; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"819689\n"); - end - xrf = 64'hBE53168DFE97BEEE; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h0010000000000000; - ans = 64'h3E63168DFE97BEED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"820303\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h402000000001FFFB; - zrf = 64'h40400000007FFFFA; - ans = 64'h40400000007FFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"820917\n"); - end - xrf = 64'h7FFD8B8508E0B4F6; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h381FFFFFFFFF7FFF; - ans = 64'h7FFD8B8508E0B4F6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"821531\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h49F000000003FEFE; - zrf = 64'h4340000000000000; - ans = 64'h46B000000003FEFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"822145\n"); - end - xrf = 64'h002FFFE0000000FF; - y = 64'h629000007FFDFFFF; - zrf = 64'hC1E002FFFFFFFFFF; - ans = 64'hC1E002FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"822759\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hC000000000000001; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"823373\n"); - end - xrf = 64'h9BF080000001FFFF; - y = 64'hC1E3B08DE8F3BD01; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"823987\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'hC01000000020007F; - ans = 64'hC010000000200080; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"824601\n"); - end - xrf = 64'hBFAFFFFFFC03FFFE; - y = 64'h3CA00003FFFEFFFE; - zrf = 64'h3CA0040000002000; - ans = 64'h3C9E07FF80402010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"825215\n"); - end - xrf = 64'hBFAFFFFFFFFC03FF; - y = 64'hC010000000000001; - zrf = 64'h0000000000000001; - ans = 64'h3FCFFFFFFFFC0401; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"825829\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hBFCFFE0000FFFFFF; - zrf = 64'h3ED001FFFFFFDFFF; - ans = 64'h3ED001FFFFFEE00F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"826443\n"); - end - xrf = 64'h3232BD6AC09064AA; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hB8000000001FFF80; - ans = 64'hB8000000001FFF80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"827057\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFF08; - zrf = 64'h4010000000000001; - ans = 64'h4010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"827671\n"); - end - xrf = 64'hF9000FFFFFFEFFFF; - y = 64'hC00FFFFFD7FFFFFF; - zrf = 64'h4FEF54534F810F43; - ans = 64'h79200FFFEBEAFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"828285\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hC340000000000000; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"828899\n"); - end - xrf = 64'hBF0B677CE222C3C4; - y = 64'h5B5007FFFFFFEFFF; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hDA6B7530A093B9BD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"829513\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hC04C8260C328A10C; - ans = 64'hC04E8260C328A10C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"830127\n"); - end - xrf = 64'hC32351DA9045BE0B; - y = 64'h83FFFFFFFBFFFFFF; - zrf = 64'h37FFFFFFDFFF8000; - ans = 64'h37FFFFFFDFFF8000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"830741\n"); - end - xrf = 64'h3E298A451963779F; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"831355\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hC3C1127530CEDD0B; - zrf = 64'h41CFFFFFFFFFFFA0; - ans = 64'h41CFFFFEEED8AC93; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"831969\n"); - end - xrf = 64'h41C000000040001F; - y = 64'hFFE0000000000001; - zrf = 64'h3A297E3D1F64A3F4; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"832583\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hC3FFFE1FFFFFFFFF; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'hC0BFFA1FFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"833197\n"); - end - xrf = 64'h58EFFFFEFFEFFFFF; - y = 64'h3FFFFFFFFFF00000; - zrf = 64'hBFE7FFFFFBFFFFFF; - ans = 64'h58FFFFFEFFE00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"833811\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hFCAFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"834425\n"); - end - xrf = 64'h41DFEFFFFFBFFFFF; - y = 64'hBCAFF00000001FFF; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hBE9FE00800003FEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"835039\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'hFFF0000000000001; - zrf = 64'h7FF0000003FFE000; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"835653\n"); - end - xrf = 64'hFFE9564FB99A2A23; - y = 64'h3FEFFFFFF7FFC000; - zrf = 64'h3F63E56EDFA19196; - ans = 64'hFFE9564FB3446388; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"836267\n"); - end - xrf = 64'hB970001FFFFEFFFE; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"836881\n"); - end - xrf = 64'h3CAFFFFFFFFFFFFE; - y = 64'h801A6DCDC520170C; - zrf = 64'h37E00004000000FE; - ans = 64'h37E00004000000FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"837495\n"); - end - xrf = 64'h4380003FFFDFFFFF; - y = 64'h0000000000000000; - zrf = 64'hC1CFFFFFFFFFFDEF; - ans = 64'hC1CFFFFFFFFFFDEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"838109\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h3FCFFFFBF0000000; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h40007FFFEFBFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"838723\n"); - end - xrf = 64'h441FFFFFFFFFFFF5; - y = 64'hC80FF800001FFFFE; - zrf = 64'h47FA1083AB1A334C; - ans = 64'hCC3FF800001FFFF3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"839337\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"839951\n"); - end - xrf = 64'h45C000000080001E; - y = 64'h4340007FFE000000; - zrf = 64'hBCA0000000000000; - ans = 64'h4910007FFE80041E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"840565\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h0010000000000000; - zrf = 64'hBAD00000003FEFFF; - ans = 64'hBAD00000003FEFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"841179\n"); - end - xrf = 64'h0000010000000400; - y = 64'h37E083FFFFFFFFFF; - zrf = 64'hC7EFFFFFFF80FFFE; - ans = 64'hC7EFFFFFFF80FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"841793\n"); - end - xrf = 64'hC3D0001FFDFFFFFF; - y = 64'h0010000000000001; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"842407\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hBFD0000000000140; - zrf = 64'hC1D1CA517F76AEDD; - ans = 64'hC1D1CA517F7AAEDD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"843021\n"); - end - xrf = 64'hC7FFFFFFFFFE001E; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h38507FFFFFFF7FFE; - ans = 64'h38507FFFFFFF7FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"843635\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hB80FFFFF000001FF; - zrf = 64'h3FF0000000000000; - ans = 64'h3FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"844249\n"); - end - xrf = 64'hB7FF0007FFFFFFFE; - y = 64'h401FE0000000007F; - zrf = 64'h41D003FFFFFFFFFD; - ans = 64'h41D003FFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"844863\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h3CA0000000000001; - zrf = 64'hC000000000000000; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"845477\n"); - end - xrf = 64'hC0B0488993492A6B; - y = 64'h5B1FFFFFDFC00000; - zrf = 64'h8010000000000001; - ans = 64'hDBE0488982E00FC5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"846091\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'hC000084000000000; - ans = 64'hC000084000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"846705\n"); - end - xrf = 64'hC1EFFFFFC0007FFF; - y = 64'h3FFFFFFFFFFFFFEE; - zrf = 64'hC8BFFFFFC00003FE; - ans = 64'hC8BFFFFFC00003FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"847319\n"); - end - xrf = 64'h375EFFFFFFFDFFFF; - y = 64'h3FD0000000000000; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"847933\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hC000000400000006; - zrf = 64'hBC1FBFFF80000000; - ans = 64'hBFE0000400000006; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"848547\n"); - end - xrf = 64'hC7E0010000FFFFFF; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hBF8FFFFFFFF83FFE; - ans = 64'hC7D0010000FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"849161\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hC0500800000001FE; - zrf = 64'h3FE0000000000001; - ans = 64'hC02F1000000003FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"849775\n"); - end - xrf = 64'hC800000004400000; - y = 64'hBE4FFFFEFFFF0000; - zrf = 64'h800FDBF9EA11BBF4; - ans = 64'h465FFFFF087EFFBC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"850389\n"); - end - xrf = 64'h3FD0000000000000; + x = 64'h3CA0000000000001; y = 64'h3FE0000000000000; - zrf = 64'hBFF0000000000001; - ans = 64'hBFEC000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"851003\n"); - end - xrf = 64'h420E5A3C24CF124B; - y = 64'hC1E07FFFFBFFFFFF; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'hC3FF4D0DFE5EFBD2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"851617\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h3FC3FFFFFFFC0000; - ans = 64'h3FD9FFFFFFFE0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"852231\n"); - end - xrf = 64'hB80AF03ED31C2128; - y = 64'h43C0003FFE000000; - zrf = 64'h47FD72CA9372EDB0; - ans = 64'h47FD72CA9372EDB0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"852845\n"); - end - xrf = 64'hB81FFFFFFDFFFFFA; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"853459\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hD414000000000000; - zrf = 64'hC3DBDCEC84BBB9FD; - ans = 64'hD3F4000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"854073\n"); - end - xrf = 64'h37F10F90DAD1F099; - y = 64'h3FF0000000000001; - zrf = 64'hBE51FF9882DDA3CC; - ans = 64'hBE51FF9882DDA3CC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"854687\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hFFFA27F828AA83E8; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'hFFFA27F828AA83E8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"855301\n"); - end - xrf = 64'hC01FFFFFFFC00008; - y = 64'hBFA7D979591E69F2; - zrf = 64'hB81FFFFFFFFC0004; - ans = 64'h3FD7D97958EEB705; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"855915\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"856529\n"); - end - xrf = 64'h7FE0DFFFFFFFFFFF; - y = 64'hBFCFFFFFFFDFFBFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"857143\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h4000000000000001; - zrf = 64'h8017C6373AB1DB0C; - ans = 64'h3FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"857757\n"); - end - xrf = 64'hBFE000800000003F; - y = 64'hC3D0040000003FFF; - zrf = 64'hBFBA1A85F9F711EA; - ans = 64'h43C0048020004040; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"858371\n"); - end - xrf = 64'hC7F0001002000000; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC810001001FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"858985\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hBB12976036C01C4E; - zrf = 64'h7FDFFF800000000F; - ans = 64'h7FDFFF800000000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"859599\n"); - end - xrf = 64'h3FFF4B7FA078868F; - y = 64'h4010000000000000; - zrf = 64'h80200000001FFFFF; - ans = 64'h401F4B7FA078868F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"860213\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hBFDCCB5937B9B37F; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'hBFBCCB5937B9B36F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"860827\n"); - end - xrf = 64'h800000000000007E; - y = 64'hFFD26A0F710537A9; - zrf = 64'hC01B3B74DE550046; - ans = 64'hC01B3B74DE550022; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"861441\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'h3FF8000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"862055\n"); - end - xrf = 64'hB9FC1DF69E92D913; - y = 64'h40800000040000FE; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"862669\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h4340000000000000; - zrf = 64'hC80BB201F0787373; - ans = 64'hC80BB201F0787373; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"863283\n"); - end - xrf = 64'hBE6CB25FEF8F51E0; - y = 64'hB0A0000000008002; - zrf = 64'hD5CFDFFFFDFFFFFF; - ans = 64'hD5CFDFFFFDFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"863897\n"); - end - xrf = 64'h47EFFFFFFFFFBDFE; - y = 64'h4340000000000001; - zrf = 64'hC000000000000000; - ans = 64'h4B3FFFFFFFFFBE00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"864511\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h3800FDCBA1FA0B89; - zrf = 64'hC030003FFEFFFFFF; - ans = 64'hC030003FFEFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"865125\n"); - end - xrf = 64'h35DD7F70FBF55C6F; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h7FEA275826182B56; - ans = 64'h7FEA275826182B56; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"865739\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hC3E0000000800007; - zrf = 64'h3CA0000000000000; - ans = 64'hC3C0000000800007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"866353\n"); - end - xrf = 64'h4340FFFFFFFFF800; - y = 64'h38ADFFFFFFBFFFFE; - zrf = 64'hBFD589A27F2B5461; - ans = 64'hBFD589A27F2B5461; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"866967\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h7FE0000000000001; - zrf = 64'hBFD0000000000000; - ans = 64'h7FC0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"867581\n"); - end - xrf = 64'h38FFFFE07FFFFFFE; - y = 64'h434000007FFF7FFF; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"868195\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hB81000003FFFFF80; - ans = 64'h7FCFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"868809\n"); - end - xrf = 64'hBD7FEFFFFFFF7FFF; - y = 64'hC1FFFFFFF000007E; - zrf = 64'h6FAFFFFFFFFFFBE0; - ans = 64'h6FAFFFFFFFFFFBE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"869423\n"); - end - xrf = 64'hC1E0000000003BFE; - y = 64'h7FF0000000000000; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"870037\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h382100000001FFFF; - zrf = 64'h43D0000010800000; - ans = 64'h43D0000010800000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"870651\n"); - end - xrf = 64'h0EDFFFFFFFBFBFFE; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'hC70FFFFFFF7BFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"871265\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hC1FFF80FFFFFFFFF; - zrf = 64'h0010000000000001; - ans = 64'hC1DFF80FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"871879\n"); - end - xrf = 64'h77500007FFFFFFFF; - y = 64'hB7EFFE0400000000; - zrf = 64'hC3CF7FFFFFFFFF00; - ans = 64'hEF4FFE13FF01FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"872493\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h8000000000000000; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"873107\n"); - end - xrf = 64'h41DFFFFFFFFFFBFE; - y = 64'hBFB00008007FFFFE; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFFFBFFFDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"873721\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hC3FFF0000003FFFF; - ans = 64'hC3FFF0000003FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"874335\n"); - end - xrf = 64'hBFE0000000000077; - y = 64'hC1E00000000003BE; - zrf = 64'hBFF000010000001F; - ans = 64'h41CFFFFFFF800862; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"874949\n"); - end - xrf = 64'h3A800000027FFFFF; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"875563\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hB2CFFFFE07FFFFFF; - zrf = 64'hBFBFFFFFFFE001FE; - ans = 64'hBFBFFFFFFFE001FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"876177\n"); - end - xrf = 64'hC00FFE00FFFFFFFF; - y = 64'h8010000000000001; - zrf = 64'h9DAFFFFFC0000001; - ans = 64'h9DAFFFFFC0000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"876791\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hC30F8FBDC122265C; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hC2EF8FBDC122265C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"877405\n"); - end - xrf = 64'h0E1FFFFFFFF0003F; - y = 64'h8D33FFFFFFFDFFFE; - zrf = 64'h43CF12C07801790B; - ans = 64'h43CF12C07801790B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"878019\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h8023FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"878633\n"); - end - xrf = 64'hC16FFFFFFFFFFFFE; - y = 64'h43DFFF8003FFFFFF; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'hC55FFF8003FFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"879247\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hBCA0000000000001; - zrf = 64'h37F00200FFFFFFFF; - ans = 64'hBC80000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"879861\n"); - end - xrf = 64'h001FB1D966CCDFCE; - y = 64'hBFC4E6F76095C1F4; - zrf = 64'h1B73746C9DC04BF1; - ans = 64'h1B73746C9DC04BF1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"880475\n"); - end - xrf = 64'h3D2FFFF820000000; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"881089\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hC3FFFFFDFFFFF7FF; - zrf = 64'h3FE0000800FFFFFE; - ans = 64'hC3DFFFFDFFFFF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"881703\n"); - end - xrf = 64'h43D3000000000000; - y = 64'hBFD0000000000000; - zrf = 64'hB7E7428087FE7255; - ans = 64'hC3B3000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"882317\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h43CCB81C98B1BC94; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"882931\n"); - end - xrf = 64'h3FD4A71E4A6E4C00; - y = 64'h3FBFFFFFFFFFFDF6; - zrf = 64'h000FFFFFFF7FFE00; - ans = 64'h3FA4A71E4A6E4AAF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"883545\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hBFBFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"884159\n"); - end - xrf = 64'hBCA00004000003FF; - y = 64'h499FFFFFFFFFE800; - zrf = 64'h4010000000000000; - ans = 64'hC6500003FFFFF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"884773\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hBFE0000000000000; - zrf = 64'hC2BFFFFFFBBFFFFF; - ans = 64'hC2BFFFFFFBC0001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"885387\n"); - end - xrf = 64'hBCAFDFFFFFFFEFFF; - y = 64'hBFEFBFFFFEFFFFFF; - zrf = 64'h3819477BBAEEBE75; - ans = 64'h3CAFA03FFF00F01E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"886001\n"); - end - xrf = 64'hBFEFFFFFFBFFFFBE; - y = 64'hBFE0000000000001; - zrf = 64'hBFD0000000000000; - ans = 64'h3FCFFFFFF7FFFF80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"886615\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h3F71F00000000000; - zrf = 64'h001C00000000003F; - ans = 64'h3F51F00000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"887229\n"); - end - xrf = 64'h3180000800000000; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h4010008000003FFF; - ans = 64'h4010008000003FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"887843\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hBFAFFFFFFFFF7BFF; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"888457\n"); - end - xrf = 64'h00299FE07104D6A3; - y = 64'h3B7007FFFFFFEFFE; - zrf = 64'h43DFFFFFF0001000; - ans = 64'h43DFFFFFF0001000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"889071\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hBFF0000000000001; - zrf = 64'h8000000000000000; - ans = 64'hBFD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"889685\n"); - end - xrf = 64'h3FCF4D325CFDD93C; - y = 64'h0016A743D6888DB5; - zrf = 64'h4000000000000001; - ans = 64'h4000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"890299\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hC0169EAB4642D2BE; - ans = 64'hC0189EAB4642D2BE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"890913\n"); - end - xrf = 64'h449FFFFFDDFFFFFE; - y = 64'h3E4FFFFB7FFFFFFF; - zrf = 64'h3FB0EE0C1F0EC5E3; - ans = 64'h42FFFFFB5E0004C6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"891527\n"); - end - xrf = 64'hC03FFFE000000001; - y = 64'hC000000000000000; - zrf = 64'hBCA0000000000001; - ans = 64'h404FFFE000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"892141\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hC00000004FFFFFFE; - zrf = 64'h40D0000000080100; - ans = 64'h40CFFFC0000EC200; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"892755\n"); - end - xrf = 64'hBFA001FFFFFFC000; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h47E0FC03BF40CC75; - ans = 64'h47E0FC03BF40CC75; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"893369\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h002000000FFFFFF7; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"893983\n"); - end - xrf = 64'h4110000A00000000; - y = 64'h59BF221FD8F50EDA; - zrf = 64'h43F03FFFFFFFF7FF; - ans = 64'h5ADF22334E48F673; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"894597\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hC010000000000000; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"895211\n"); - end - xrf = 64'hC12FFFFFFFE00000; - y = 64'hC3EFFEFFFFFFFFFF; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h452FFEFFFFE000FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"895825\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hC5BEEB8D6F57D560; - ans = 64'hC5BEEB8D6F57D560; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"896439\n"); - end - xrf = 64'h3CAFFFBFFFFFDFFF; - y = 64'hC1C5DE58051F8BE2; - zrf = 64'hC0E000000003FFBE; - ans = 64'hC0E0000000045737; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"897053\n"); - end - xrf = 64'h3F2FFFFFFFFDF7FE; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'hBF5FFFFFFFFDF7FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"897667\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h404001D305E5077D; - zrf = 64'h43E345C0BA2B4702; - ans = 64'h43E345C0BA2B4702; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"898281\n"); - end - xrf = 64'h400FFEFFFFFEFFFF; - y = 64'hC340000000000001; - zrf = 64'hBFC8084BF0E72845; - ans = 64'hC35FFEFFFFFF0001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"898895\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h451FC0FFFFFFFFFF; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'h44FFC0FFFBFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"899509\n"); - end - xrf = 64'h43AFFFFFBFFFFFFB; - y = 64'h801000001FFBFFFF; - zrf = 64'h41DFFFFFFFFFFFCE; - ans = 64'h41DFFFFFFFFFFFCE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"900123\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"900737\n"); - end - xrf = 64'h6BFFFFBFFFFFFFFC; - y = 64'h283FFFFFFDFBFFFF; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h544FFFBFFDFC0403; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"901351\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hFFE0000000000000; - zrf = 64'h161FFFFFFFDFFFFF; - ans = 64'hFFC0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"901965\n"); - end - xrf = 64'h37F2080000000000; - y = 64'h3FCEFFFFFFFFFFFF; - zrf = 64'h4340000000420000; - ans = 64'h4340000000420000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"902579\n"); - end - xrf = 64'hB92000FFFF7FFFFF; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h792000FFFF7FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"903193\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hFFDBC6970DE3B50D; - zrf = 64'h40683D253D82068E; - ans = 64'hFFBBC6970DE3B50D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"903807\n"); - end - xrf = 64'h41DFE00000003FFF; - y = 64'hFFF0000000000000; - zrf = 64'h3E2044A8CC924DF6; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"904421\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'h37FC1EB686A59815; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"905035\n"); - end - xrf = 64'h3E400002FFFFFFFF; - y = 64'h381FFFFF40000000; - zrf = 64'hBE7403C848DDC703; - ans = 64'hBE7403C848DDC703; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"905649\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"906263\n"); - end - xrf = 64'h3FE23B78B59A3A59; - y = 64'hB8100E2F27603D95; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"906877\n"); - end - xrf = 64'h3FD0000000000000; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h000000200000001E; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"907491\n"); - end - xrf = 64'h41CFFFC0000FFFFE; - y = 64'h43CFF7FFFFFFEFFF; - zrf = 64'hBF89D89F52C2F13F; - ans = 64'h45AFF7C0100FEBFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"908105\n"); - end - xrf = 64'h47F9AA99D39DD7D8; - y = 64'h0000000000000001; - zrf = 64'h8000000000000000; - ans = 64'h04D9AA99D39DD7D8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"908719\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hE3D0000000017FFE; - zrf = 64'h43EFC00000001FFF; - ans = 64'hE3B0000000017FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"909333\n"); - end - xrf = 64'hFFDFFE0000003FFE; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h3FCFFFFFF6000000; - ans = 64'hBFFBFE0001403FFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"909947\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hC1DFDFFFFFFFFFBE; - zrf = 64'hC010000000000000; - ans = 64'hC1BFE00003FFFFC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"910561\n"); - end - xrf = 64'h3CA80FFFFFFFFFFE; - y = 64'hB7EAF87E635B0699; - zrf = 64'h3F5000000007FFF8; - ans = 64'h3F5000000007FFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"911175\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h0010000000000001; - zrf = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"911789\n"); - end - xrf = 64'hBFBFFFFFFFEFFFDF; - y = 64'hBE92E82AF51517D5; - zrf = 64'h3FD0000000000001; - ans = 64'h3FD0000025D055EB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"912403\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hBCA007FFFFFFFFFF; - ans = 64'hBCA007FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"913017\n"); - end - xrf = 64'hC34FFFFFFE002000; - y = 64'h2E88C0F902659DDC; - zrf = 64'hB1AFFFFDFBFFFFFE; - ans = 64'hB1EAC0F8E099A70D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"913631\n"); - end - xrf = 64'hC7E003FFFFBFFFFF; - y = 64'h3CA0000000000000; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"914245\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hB5DF393CDBFD0E56; - zrf = 64'h2FF001EFFFFFFFFF; - ans = 64'hB5BF393CDBFD0E58; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"914859\n"); - end - xrf = 64'h7FF000000FFFFDFF; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hC02FB1C8D71620A8; - ans = 64'h7FF800000FFFFDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"915473\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h3D80000040020000; - zrf = 64'hC000000000000001; - ans = 64'hBFFFFFFFFFFFF802; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"916087\n"); - end - xrf = 64'hC01B8BE39B34B0D4; - y = 64'hBFE02000000007FE; - zrf = 64'h41D000000000803F; - ans = 64'h41D0000000DE981A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"916701\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h3FD0000000000000; - zrf = 64'h4010000000000001; - ans = 64'h4010400000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"917315\n"); - end - xrf = 64'hBCA00FFFFFFFFFFE; - y = 64'h4FEFFFFFFFFFDDFF; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hCCA00FFFFFFFEEEC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"917929\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h3FD0000000000001; - zrf = 64'h3FCF035416EA0254; - ans = 64'h3FD381AA0B75012B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"918543\n"); - end - xrf = 64'hBB20000000000800; - y = 64'h3800000008400000; - zrf = 64'h4340000090000000; - ans = 64'h4340000090000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"919157\n"); - end - xrf = 64'h47F000000001F800; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"919771\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h4000010003FFFFFF; - zrf = 64'h347FFFFFFFE00004; - ans = 64'h3FE0010004000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"920385\n"); - end - xrf = 64'h41D56D000350CB1C; - y = 64'h3FE0000000000000; - zrf = 64'h405D74B8307164A8; - ans = 64'h41C56D003E3A3B7D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"920999\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hC00000FFFFFFFFC0; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hC004003FFFFFFFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"921613\n"); - end - xrf = 64'h3CACF1F103A120CF; - y = 64'h47BFFFBFFFFFC000; - zrf = 64'hC2E3FEFFFFFFFFFF; - ans = 64'h447CF1B715BF5FA9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"922227\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h4010FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"922841\n"); - end - xrf = 64'hCE40000000000210; - y = 64'h3FEFF81FFFFFFFFF; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'hCE3FF8200000041E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"923455\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h3FF0000000000000; - zrf = 64'h0452200000000000; - ans = 64'h3FD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"924069\n"); - end - xrf = 64'h3F80000200000FFF; - y = 64'h3810000000FFE000; - zrf = 64'h43EB023AC93CBEFB; - ans = 64'h43EB023AC93CBEFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"924683\n"); - end - xrf = 64'h400AE69468F30B18; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h4350000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"925297\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h47FFFDFFFFFFF7FF; - zrf = 64'hBFEFF0000000001F; - ans = 64'h47DFFDFFFFFFF801; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"925911\n"); - end - xrf = 64'hC7FFFFFFFFF000FE; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h7FE129213A6A1E19; - ans = 64'h7FE129213A6A1E19; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"926525\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h41F1FFFFFF800000; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'h41D1FFFFFF400001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"927139\n"); - end - xrf = 64'h43FFFFFFFFFFFFFF; - y = 64'hBFFF7027F837860A; - zrf = 64'h38100100000FFFFF; - ans = 64'hC40F7027F8378609; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"927753\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h4007FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"928367\n"); - end - xrf = 64'hB7000000201FFFFE; - y = 64'h403C000080000000; - zrf = 64'h0010000000000000; - ans = 64'hB74C0000B83800FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"928981\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h3FDFFFFFFFFDEFFF; - ans = 64'h3FF7FFFFFFFF7C00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"929595\n"); - end - xrf = 64'h41EFFFFFFFFFE03F; - y = 64'hC3F0800000010000; - zrf = 64'h4000000000000006; - ans = 64'hC5F080000000EFA0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"930209\n"); - end - xrf = 64'hBFD04D24C5BAD8C9; - y = 64'h4010000000000001; - zrf = 64'h4340000000000000; - ans = 64'h433FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"930823\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h43EFFBFFFFFFFFF7; - zrf = 64'h4FBFBFC000000000; - ans = 64'h4FBFBFC000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"931437\n"); - end - xrf = 64'h2106EEC68B20AD3B; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h8013FFFE00000000; - ans = 64'h2136EEC68B20AD3A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"932051\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hB8CFFFDFFDFFFFFF; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"932665\n"); - end - xrf = 64'h7FF00001FFFFFF7F; - y = 64'h43EFFF7FBFFFFFFF; - zrf = 64'hC09FFFFFDFFFFF80; - ans = 64'h7FF80001FFFFFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"933279\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h4340000000000001; - zrf = 64'h3FF0000000000000; - ans = 64'h4320000000000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"933893\n"); - end - xrf = 64'h407E7C49B84A1813; - y = 64'h7FEC9DC7A22C5F2A; - zrf = 64'h0000000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"934507\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'hC66000008000001F; - ans = 64'hC66000008000001D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"935121\n"); - end - xrf = 64'h3E70FFFFFF000000; - y = 64'h400FFF8100000000; - zrf = 64'h426000100001FFFF; - ans = 64'h426000100001FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"935735\n"); - end - xrf = 64'hBDDBFFFFFEFFFFFF; - y = 64'h7FE0000000000000; - zrf = 64'h4010000000000001; - ans = 64'hFDCBFFFFFEFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"936349\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h4344EFFCAA357859; - zrf = 64'h3CAFFF000000007E; - ans = 64'h4324EFFCAA35785A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"936963\n"); - end - xrf = 64'hBFA1E04D77711DA5; - y = 64'h7FE0000000000001; - zrf = 64'h37E79B4E706CAB4B; - ans = 64'hFF91E04D77711DA6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"937577\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hB81000080000001E; - zrf = 64'hBFD0000000000001; - ans = 64'hBFD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"938191\n"); - end - xrf = 64'h41FFFE8000000000; - y = 64'h3FCFFF7FFFDFFFFF; - zrf = 64'hF61FFC8000000000; - ans = 64'hF61FFC8000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"938805\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h7FF0000000000000; - zrf = 64'h3FE0000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"939419\n"); - end - xrf = 64'h3FC287A64DA52860; - y = 64'h1C903FFFFFC00000; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"940033\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h7FF0000000000001; - zrf = 64'hBCA82E7990B52CC4; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"940647\n"); - end - xrf = 64'hC010000003FBFFFF; - y = 64'hC7E38964973306D4; - zrf = 64'hB80004FFFFFFFFFE; - ans = 64'h480389649C107D9F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"941261\n"); - end - xrf = 64'h3DE46B9905A7DCC3; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h400FFFFFFFFFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"941875\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h7FF0EF17815B5D60; - zrf = 64'h15AC93DCB8E5466F; - ans = 64'h7FF8EF17815B5D60; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"942489\n"); - end - xrf = 64'h80102FFFFFFFFFFF; - y = 64'h8000000000000000; - zrf = 64'hB7EFFFFF5FFFFFFF; - ans = 64'hB7EFFFFF5FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"943103\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h800363A5C355B338; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"943717\n"); - end - xrf = 64'h388238397A22857F; - y = 64'hBCCDFFFBFFFFFFFE; - zrf = 64'hBFBBFFFFF8000000; - ans = 64'hBFBBFFFFF8000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"944331\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"944945\n"); - end - xrf = 64'h41AFFFFFFFBF7FFF; - y = 64'hC0091C99F8B11DCA; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"945559\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h8010000000000000; - zrf = 64'h3CA814604180F249; - ans = 64'h3CA814604180F249; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"946173\n"); - end - xrf = 64'h3FCFFF80001FFFFF; - y = 64'h3FECEAFB782ECD40; - zrf = 64'hC3D9BA4276C0833E; - ans = 64'hC3D9BA4276C0833E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"946787\n"); - end - xrf = 64'h64A007F7FFFFFFFF; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h3FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"947401\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h380FFFFFFFFFFFEF; - zrf = 64'hC01FFFFFBFFFFFBF; - ans = 64'hC01FFFFFBFFFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"948015\n"); - end - xrf = 64'hA5D382EB96AD50AD; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'hC5300000FFFFF800; - ans = 64'hC5300000FFFFF800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"948629\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h3FCFFFFFFFFBFFFF; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h3FAFFFFFFFFC0001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"949243\n"); - end - xrf = 64'h400FFFFFFE000200; - y = 64'hC7E08000000003FF; - zrf = 64'hC030000000003FF0; - ans = 64'hC8007FFFFEF80507; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"949857\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h3CA7FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"950471\n"); - end - xrf = 64'h3FFFFFFFFFF80FFF; - y = 64'hC3F0000000000081; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"951085\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h002F0003FFFFFFFF; - ans = 64'hBC90000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"951699\n"); - end - xrf = 64'hBFBFFFFFFFFFFFFF; - y = 64'h00100000000001F7; - zrf = 64'h37FFFEFFFFFFFEFF; - ans = 64'h37FFFEFFFFFFFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"952313\n"); - end - xrf = 64'h3E771CF6C17F0752; - y = 64'hBFD0000000000001; - zrf = 64'h3FF0000000000000; - ans = 64'h3FEFFFFFF471849F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"952927\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hBFB0008000000FFF; - zrf = 64'h40DB1A37D21A1798; - ans = 64'h40DB1A36D2121798; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"953541\n"); - end - xrf = 64'hBFDFFBFF80000000; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hBFB000000007FFF0; - ans = 64'h3FC7FBFF7FFC0007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"954155\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hC033697E014548B4; - zrf = 64'h8010000000000000; - ans = 64'hC013697E014548B5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"954769\n"); - end - xrf = 64'hBFFA87A874A05E30; - y = 64'hC8211E73E27BE4D9; - zrf = 64'h53F00003FFFFFFF7; - ans = 64'h53F00003FFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"955383\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hBFE0000000000001; - zrf = 64'h3CA0000000000000; - ans = 64'hBFBFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"955997\n"); - end - xrf = 64'hBFDFFC3FFFFFFFFF; - y = 64'h40103FFFFFFDFFFF; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"956611\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hBF145491BF6D4A83; - ans = 64'hBFD00145491BF6D5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"957225\n"); - end - xrf = 64'h408C000001FFFFFF; - y = 64'h0001FFFFFFFFFF00; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"957839\n"); - end - xrf = 64'h96CFFFFFFBFFFFFF; - y = 64'hBFF0000000000000; - zrf = 64'h3FE0000000000001; - ans = 64'h3FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"958453\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hC7F100FE84589A72; - zrf = 64'h3A9FFBFDFFFFFFFF; - ans = 64'hC7D100FE84589A73; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"959067\n"); - end - xrf = 64'hC3CE1EC5802CC41D; - y = 64'hBFF0000000000001; - zrf = 64'hBFFFFFF8000FFFFE; - ans = 64'h43CE1EC5802CC41F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"959681\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h41D0000000000400; - zrf = 64'h8000000000000001; - ans = 64'h41B0000000000401; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"960295\n"); - end - xrf = 64'h3FC0000200020000; - y = 64'hCC503FFFFFFFEFFF; - zrf = 64'h402BD7CA595315B7; - ans = 64'hCC2040020801F7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"960909\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hC000000000000000; - zrf = 64'h0010000000000001; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"961523\n"); - end - xrf = 64'h4133D265E1ABC512; - y = 64'h3806B3BED3DAFA47; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"962137\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hC000000000000001; - zrf = 64'h444FFFFFFFFE0FFF; - ans = 64'h444FFFFFFFFE0FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"962751\n"); - end - xrf = 64'hC7FFC00000000200; - y = 64'h374FFFFFFFFF81FF; - zrf = 64'h3CF99D8CF88F4CC9; - ans = 64'hBF5FBFFFFFFF1E85; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"963365\n"); - end - xrf = 64'hB7F000000004003E; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"963979\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h40301FFFFFFFFDFF; - zrf = 64'hB81BFFFFFFFFF000; - ans = 64'h40101FFFFFFFFE00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"964593\n"); - end - xrf = 64'hC02AB5A6C8558DF5; - y = 64'hC010000000000000; - zrf = 64'hC04EF71DE29A8DE5; - ans = 64'hC02105DC6913FFC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"965207\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h8008AB84C5B2AF24; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"965821\n"); - end - xrf = 64'h3FB13CA24F24198A; - y = 64'h031FC7FFFFFFFFFF; - zrf = 64'hC7CFFDFFFFFF0000; - ans = 64'hC7CFFDFFFFFF0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"966435\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"967049\n"); - end - xrf = 64'h40139F95932450BC; - y = 64'h3FCF7FFF7FFFFFFF; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC006577488D34B68; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"967663\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hC340000000000000; - zrf = 64'h002FFEFFFFFEFFFF; - ans = 64'hC320000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"968277\n"); - end - xrf = 64'h41EFFFFFF7FFFFFC; - y = 64'h40D000080001FFFF; - zrf = 64'h403EFFFDFFFFFFFF; - ans = 64'h42D00007FC0205BD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"968891\n"); - end - xrf = 64'hC80FFFFF6FFFFFFE; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h4B6FFFFF6FFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"969505\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h43D000FFF7FFFFFE; - zrf = 64'hBF8EFDFFFFFFFFFF; - ans = 64'h43B000FFF7FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"970119\n"); - end - xrf = 64'h00200000002001FF; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hC7E000000000100F; - ans = 64'hC7E000000000100F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"970733\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'h126000000002007F; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"971347\n"); - end - xrf = 64'h3FDFFFFFFEF00000; - y = 64'hC01010000000000F; - zrf = 64'h3FEFFFFFFFFDFBFF; - ans = 64'hBFF01FFFFEEFF21E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"971961\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hFFE0000000000001; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"972575\n"); - end - xrf = 64'h3EFFFC000000001E; - y = 64'hBFEFFFFFFFFFEDFF; - zrf = 64'hC000000000000000; - ans = 64'hC000000FFE000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"973189\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h401FBFFFF7FFFFFE; - ans = 64'hFFD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"973803\n"); - end - xrf = 64'h473FFFFF88000000; - y = 64'hB040FFFFFBFFFFFF; - zrf = 64'hC160000002FFFFFE; - ans = 64'hC160000002FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"974417\n"); - end - xrf = 64'hC1D037A403FC67CA; - y = 64'hFFF0000000000001; - zrf = 64'h3CA0000000000000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"975031\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hC7FFFFFFFFFF0040; - zrf = 64'hC0105563F3CA3EC6; - ans = 64'hC7DFFFFFFFFF0042; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"975645\n"); - end - xrf = 64'h37FFFDFFFDFFFFFF; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h53E00000047FFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"976259\n"); - end - xrf = 64'h3FD0000000000001; - y = 64'hBEAFF800001FFFFE; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"976873\n"); - end - xrf = 64'hC1F003DFFFFFFFFF; - y = 64'h401E15640A85ECF6; - zrf = 64'hC7F00080000001FF; - ans = 64'hC7F00080000001FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"977487\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h0000000000000000; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"978101\n"); - end - xrf = 64'hBFE0000008007FFE; - y = 64'hBF3FF8000000FFFF; - zrf = 64'hBFF0000000000001; - ans = 64'hBFEFFE007FFF0022; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"978715\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h3E40000000400FFE; - ans = 64'h3E40000000400FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"979329\n"); - end - xrf = 64'hBEE07FFFFFE00000; - y = 64'hBCA971847D137B50; - zrf = 64'hBFDFE00001FFFFFF; - ans = 64'hBFDFE00001FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"979943\n"); - end - xrf = 64'hC3C8F08B471AE667; - y = 64'h0010000000000000; - zrf = 64'h0010000000000001; - ans = 64'h83E8F08B471AE667; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"980557\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'hBC1FFE0000100000; - zrf = 64'hBFF00001FBFFFFFF; - ans = 64'hBFF00001FBFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"981171\n"); - end - xrf = 64'h3FFFFFFFFFFFDEFF; - y = 64'h0010000000000001; - zrf = 64'hB560400007FFFFFF; - ans = 64'hB560400007FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"981785\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h39300000F8000000; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"982399\n"); - end - xrf = 64'hD090FFFFFFFFFFC0; - y = 64'h3FBFFFFFFFFFEFF6; - zrf = 64'hC02FFFFFEF000000; - ans = 64'hD060FFFFFFFFF73B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"983013\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"983627\n"); - end - xrf = 64'hBFF0100001FFFFFF; - y = 64'h317FFFFFFFFFFC1E; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"984241\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h3CA0000000000001; - zrf = 64'h3E5FFFFFFFFE0002; - ans = 64'h3E600000007F0001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"984855\n"); - end - xrf = 64'hBFF2502429256768; - y = 64'hC7F2ED05D0BFF7AA; - zrf = 64'h2B964D394AA258C9; - ans = 64'h47F5A9726DE4697B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"985469\n"); - end - xrf = 64'hBFC0000400000000; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hBC800003FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"986083\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h7FFFFF7FEFFFFFFF; - zrf = 64'hC00000002000FFFF; - ans = 64'h7FFFFF7FEFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"986697\n"); - end - xrf = 64'h3FCF80003FFFFFFF; - y = 64'h3FD0000000000000; - zrf = 64'h4BA081FFFFFFFFFE; - ans = 64'h4BA081FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"987311\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'hC010202000000000; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h4017EFEFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"987925\n"); - end - xrf = 64'h002FC07FFFFFFFFE; - y = 64'hBC40001000020000; - zrf = 64'h3930000000FF7FFF; - ans = 64'h3930000000FF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"988539\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"989153\n"); - end - xrf = 64'hBFF57175CE514C3A; - y = 64'hAEDA36C72E77963A; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"989767\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h3FE0000000000000; - zrf = 64'hB81D8C6AFBEFCF8A; - ans = 64'h3FCFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"990381\n"); - end - xrf = 64'h3FDFC00000000006; - y = 64'h3D908358E704FD5A; - zrf = 64'h3CAFFFFFFF0007FF; - ans = 64'h3D8062D23536EF63; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"990995\n"); - end - xrf = 64'hBCB003FF7FFFFFFF; - y = 64'h3FE0000000000001; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"991609\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h0007DFFFFFFFFFFE; - zrf = 64'h41DFFFFFDFFFE000; - ans = 64'h41DFFFFFDFFFE000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"992223\n"); - end - xrf = 64'hBCA7FFFFFFFFFFC0; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'hB3B6000000000000; - ans = 64'hBCA7FFFFFFFFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"992837\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h38100000FDFFFFFE; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"993451\n"); - end - xrf = 64'h37F0000008000000; - y = 64'h3FDFFFFFFFF00008; - zrf = 64'h73300F7FFFFFFFFF; - ans = 64'h73300F7FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"994065\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h3FF0000000000001; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01DFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"994679\n"); - end - xrf = 64'h3C0FFFFFFFFEF7FF; - y = 64'hB4CFFFFFFFFFFFFF; - zrf = 64'hBFD0000000000000; - ans = 64'hBFD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"995293\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h480FFFFFFFFFFF3E; - ans = 64'h480FFFFFFFFFFF3E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"995907\n"); - end - xrf = 64'h6A10000000080010; - y = 64'hC021000000000001; - zrf = 64'h43F0003FFFFFDFFF; - ans = 64'hEA41000000088012; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"996521\n"); - end - xrf = 64'h3FF0000007FFF000; - y = 64'h4000000000000000; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"997135\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'hC00867B6EE5CD554; - zrf = 64'h480FFFFFFFEFFBFF; - ans = 64'h480FFFFFFFEFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"997749\n"); - end - xrf = 64'h36BF0007FFFFFFFF; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h400FC00000000000; - ans = 64'h400FC00000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"998363\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h3CA0000000000240; - zrf = 64'h4000000000000000; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"998977\n"); - end - xrf = 64'hC02FFFFFFFFF7DFF; - y = 64'hD29FFFE1FFFFFFFF; - zrf = 64'hD095BF0E8082970E; - ans = 64'h52DFFFE1FFFE220E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"999591\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h4010000000000000; - zrf = 64'hC010000000000000; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1000205\n"); - end - xrf = 64'h41C03FFF7FFFFFFE; - y = 64'hC1DA356842BBA7BA; - zrf = 64'hBCA0000000000001; - ans = 64'hC3AA9E3D121B5440; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1000819\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hC0C3FFDFFFFFFFFF; - ans = 64'hC0C3FDDFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1001433\n"); - end - xrf = 64'hC1CFFE0007FFFFFF; - y = 64'h80000001FFFFFFFB; - zrf = 64'h3EE00001FFEFFFFF; - ans = 64'h3EE00001FFEFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1002047\n"); - end - xrf = 64'h41CFFFFFF000007F; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1002661\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h7FFFFFFFFF8007FF; - zrf = 64'h3F25B91F0BABFF28; - ans = 64'h7FFFFFFFFF8007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1003275\n"); - end - xrf = 64'h40EE0A93E8691D04; - y = 64'h4340000000000001; - zrf = 64'hC7FFEFFFFBFFFFFF; - ans = 64'hC7FFEFFFFBFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1003889\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h7FF007FF7FFFFFFF; - zrf = 64'h3FF0000000000001; - ans = 64'h7FF807FF7FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1004503\n"); - end - xrf = 64'hC5700000003FC000; - y = 64'h583FFFDFFFFFFF7E; - zrf = 64'h3FCFDFFFFFFFFFFF; - ans = 64'hDDBFFFE0007F7EFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1005117\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hC000000000000001; - ans = 64'h433FFFFFFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1005731\n"); - end - xrf = 64'h47F4511545A3B643; - y = 64'hC39FFC0000010000; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'hCBA44E8B22FBA455; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1006345\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h7FE0000000000001; - zrf = 64'h002FFFFFFFC04000; - ans = 64'h7FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1006959\n"); - end - xrf = 64'h41CD1B44159CA902; - y = 64'h7FFFFFFBFFFFFFFF; - zrf = 64'hBFE6D13A7491C894; - ans = 64'h7FFFFFFBFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1007573\n"); - end - xrf = 64'h4602638FB47E42DE; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1008187\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h402000000000040F; - zrf = 64'h41CFF7FFFDFFFFFF; - ans = 64'h41CFF7FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1008801\n"); - end - xrf = 64'h3C4EFFFFFFFFEFFE; - y = 64'h7FF0000000000000; - zrf = 64'hBEEE03FFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1009415\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h43EFFC0000001FFE; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h43DFFC0000001FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1010029\n"); - end - xrf = 64'hC7EFFF000007FFFF; - y = 64'h802FFFFFF0000400; - zrf = 64'hC3CE000001FFFFFF; - ans = 64'hC3CE000001FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1010643\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1011257\n"); - end - xrf = 64'h3FEFFFFFFFFFE07F; - y = 64'hC3C0000002000FFE; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hC3C000000200003D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1011871\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h8000000000000000; - zrf = 64'h43CFC00400000000; - ans = 64'h43CFC00400000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1012485\n"); - end - xrf = 64'hAB85C1F0653D248E; - y = 64'hC3FFFFFFFFBE0000; - zrf = 64'h3FD41CD3A8479F2D; - ans = 64'h3FD41CD3A8479F2D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1013099\n"); - end - xrf = 64'h41DFFFF000008000; - y = 64'h8000000000000001; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1013713\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'hC66E09CF3AF6E013; - zrf = 64'h511B551EA6EE8C23; - ans = 64'h511B551EA6EE8C23; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1014327\n"); - end - xrf = 64'h403A4AD510299EB1; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h1BCDE79C5FF69901; - ans = 64'h1BCDE79C5FF69901; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1014941\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h5CEE79D6389C3B59; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h5CDE79D6389C3B58; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1015555\n"); - end - xrf = 64'hC3FFFFFFFFFF8002; - y = 64'h43CF81FFFFFFFFFF; - zrf = 64'hC1F0FBFFFFFFFFFF; - ans = 64'hC7DF81FFFFFF81F9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1016169\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h8010000000000001; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hBFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1016783\n"); - end - xrf = 64'h52B00007EFFFFFFE; - y = 64'hB80000020000003F; - zrf = 64'h8000000000000000; - ans = 64'hCAC00009F000FE3D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1017397\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'hDB40000010003FFF; - ans = 64'hDB40000010003FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1018011\n"); - end - xrf = 64'hAA1003FFFFFFFFBF; - y = 64'h400EFCB55B759507; - zrf = 64'h41E00100007FFFFF; - ans = 64'h41E00100007FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1018625\n"); - end - xrf = 64'h3ACA98EA817AAD44; - y = 64'hBCA0000000000000; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1019239\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h8762BBDF1A21B496; - zrf = 64'h3810000003FBFFFF; - ans = 64'h3810000003FBFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1019853\n"); - end - xrf = 64'hBFF0000080008000; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'hCD6FF7FFFFFC0000; - ans = 64'hCD6FF7FFFFFC0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1020467\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h4090000000000011; - zrf = 64'h3FD0000000000000; - ans = 64'h4080020000000010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1021081\n"); - end - xrf = 64'hFFEFE00002000000; - y = 64'hBEAFEFFFFFFF7FFF; - zrf = 64'h41C1D04549226D33; - ans = 64'h7EAFD01001FE807F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1021695\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'hBFD0000000000000; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE4000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1022309\n"); - end - xrf = 64'hBFE0000003FDFFFF; - y = 64'hC00FFF7FFFF80000; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1022923\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h3FFFFFFFFFFFF7F0; - ans = 64'h3FFBFFFFFFFFF7F0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1023537\n"); - end - xrf = 64'h38FFFFFFFFFDFF7E; - y = 64'h9B8004000000000F; - zrf = 64'h2FDFFF8000000008; - ans = 64'h2FDFFF8000000008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1024151\n"); - end - xrf = 64'h3FE00001FFFEFFFF; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'hC000000000000001; - ans = 64'hC00200003FFFE001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1024765\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'hC1CFFF000FFFFFFE; - zrf = 64'h7FD8040000000000; - ans = 64'h7FD8040000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1025379\n"); - end - xrf = 64'hC10FFFFFFFFFFEFE; - y = 64'hBFE0000000000001; - zrf = 64'hFFD0003F7FFFFFFF; - ans = 64'hFFD0003F7FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1025993\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h4B05E5A08426A286; - zrf = 64'h3CA0000000000001; - ans = 64'h4AF5E5A08426A285; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1026607\n"); - end - xrf = 64'hF5E0000FFFF7FFFF; - y = 64'h4017BFFFFFFFFFFE; - zrf = 64'hBFB3A6B42E1910C4; - ans = 64'hF607C017BFF41FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1027221\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hBFD0000000000001; - ans = 64'hBFE7FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1027835\n"); - end - xrf = 64'h3FBFE00007FFFFFF; - y = 64'hC01FFFFFFFFE000F; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1028449\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'hBFF0000000000001; - zrf = 64'h3813A2BEB5826B36; - ans = 64'hBFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1029063\n"); - end - xrf = 64'h3D7FFFFFFFFDFFFD; - y = 64'hBF1A0514D4BED171; - zrf = 64'h401FA4D562334CE0; - ans = 64'h401FA4D562334CE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1029677\n"); - end - xrf = 64'hA720000FFE000000; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1030291\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'hBF950025543D3C42; - zrf = 64'hBFDB40EC8C50107B; - ans = 64'hBFDBE8EDB6F1FA5D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1030905\n"); - end - xrf = 64'hBFEF000004000000; - y = 64'hC000000000000000; - zrf = 64'hC34FF80000000006; - ans = 64'hC34FF80000000005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1031519\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h43EBFFFFFF800000; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h43DBFFFFFF7FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1032133\n"); - end - xrf = 64'h3E2400000000000F; - y = 64'h43F03213356F2EC0; - zrf = 64'h01B2E18AE3758A2A; - ans = 64'h42243E9802CAFA7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1032747\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1033361\n"); - end - xrf = 64'hC7E00FFFFEFFFFFE; - y = 64'hA0FFFFF80000007E; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1033975\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'hC010000000000000; - zrf = 64'h41CE0FFFFFFFFFFF; - ans = 64'h41CE0FFFFEFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1034589\n"); - end - xrf = 64'hBFE001000001FFFE; - y = 64'h41C0400000040000; - zrf = 64'hBDAF0000000001FF; - ans = 64'hC1B041040006083E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1035203\n"); - end - xrf = 64'h48000000001FBFFF; - y = 64'hC010000000000001; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hC8200000001FC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1035817\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'hC3F00FFFFBFFFFFE; - zrf = 64'hC1EFF80000200000; - ans = 64'hC3E00FFFFC1FF7FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1036431\n"); - end - xrf = 64'hC1D0001000000020; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hBFFFFFFE000001FF; - ans = 64'h4200000FFFF00020; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1037045\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'hA3700000000FFFBF; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'hA3600000000FFFBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1037659\n"); - end - xrf = 64'hA68BFDFFFFFFFFFF; - y = 64'h43FFFFFFE000003F; - zrf = 64'hFFDFF7FFFFFC0000; - ans = 64'hFFDFF7FFFFFC0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1038273\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'hC340000000000001; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'hC330000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1038887\n"); - end - xrf = 64'hBFE0010000007FFF; - y = 64'h3FF00003FFFFFF7F; - zrf = 64'h4340000000000000; - ans = 64'h433FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1039501\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h37E57439B2172858; - ans = 64'hC33FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1040115\n"); - end - xrf = 64'h479FFFFF0FFFFFFF; - y = 64'hBCAFFF7FFFFFFFFE; - zrf = 64'h3FF11E1E3AE7A649; - ans = 64'hC45FFF7F1003BFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1040729\n"); - end - xrf = 64'h7FD00FFFFFFF0000; - y = 64'hFFE0000000000000; - zrf = 64'hBFE0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1041343\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'hDF70080000000006; - zrf = 64'hC3400000FFFF0000; - ans = 64'hDF60080000000005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1041957\n"); - end - xrf = 64'hC034D2BDB10C9441; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h434FC0000001FFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1042571\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'h43F00001FFF7FFFE; - zrf = 64'h0000000000000000; - ans = 64'h43E00001FFF7FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1043185\n"); - end - xrf = 64'hC7EFFFC007FFFFFF; - y = 64'hC2D0000000000001; - zrf = 64'h40000000007FFFFF; - ans = 64'h4ACFFFC008000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1043799\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'hFFF0000000000000; - zrf = 64'h8010000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1044413\n"); - end - xrf = 64'h3FBF09191E8A701F; - y = 64'hB17DB7CAEE1A39D7; - zrf = 64'h4010000000000001; - ans = 64'h4010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1045027\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hC02FFFFFFFC0000F; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1045641\n"); - end - xrf = 64'h381FFFFFF8000400; - y = 64'hBD60081FFFFFFFFF; - zrf = 64'hA9AFFFFEFFFFFFEF; - ans = 64'hB590081FFBFDFA00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1046255\n"); - end - xrf = 64'hC80EEC83DDF4CD6E; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'hBFD0000000000001; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1046869\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hC7E0000000100007; - zrf = 64'h31A007FEFFFFFFFF; - ans = 64'hC7D0000000100006; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1047483\n"); - end - xrf = 64'h47EFFEFFFFF7FFFF; - y = 64'h0000000000000001; - zrf = 64'h3FD007FFFFFFFFFA; - ans = 64'h3FD007FFFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1048097\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h001003FFFFFFDFFF; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1048711\n"); - end - xrf = 64'hD34001FFFFEFFFFF; - y = 64'h41C2BE85AF0F08B3; - zrf = 64'hB6FFFFFFFDFFBFFF; - ans = 64'hD512C0DD7FB22C0D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1049325\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h8000000000000001; - ans = 64'h0007FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1049939\n"); - end - xrf = 64'hB7E0000000000107; - y = 64'h3BCFEF765FA7E0D8; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h400FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1050553\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h0010000000000001; - zrf = 64'hAE9FFE000001FFFF; - ans = 64'hAE9FFE000001FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1051167\n"); - end - xrf = 64'h3F5FBEFFFFFFFFFF; - y = 64'h43EFEFFFFFFFF7FF; - zrf = 64'hBFE0007FFBFFFFFF; - ans = 64'h435FAF207FFFF80E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1051781\n"); - end - xrf = 64'hC887A462950B860F; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1052395\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hC7FFFFFFF003FFFE; - zrf = 64'h400407F04DA9C1E6; - ans = 64'hC7EFFFFFF003FFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1053009\n"); - end - xrf = 64'hBECBC8424E208DC2; - y = 64'h3CA0000000000000; - zrf = 64'h43ED932CB1DF65E5; - ans = 64'h43ED932CB1DF65E5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1053623\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hBFEFFFFF7FFEFFFE; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1054237\n"); - end - xrf = 64'h37E176462F866ECA; - y = 64'h3FCDFFFFFFFFEFFF; - zrf = 64'hC21A985D8C29A10F; - ans = 64'hC21A985D8C29A10F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1054851\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1055465\n"); - end - xrf = 64'h40CFFFFFFF7DFFFE; - y = 64'h41F781EC9ADCFA89; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h42D781EC9A7D7B36; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1056079\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h3FD0000000000000; - zrf = 64'h7FD03FFFDFFFFFFF; - ans = 64'h7FD03FFFDFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1056693\n"); - end - xrf = 64'h43400000100001FE; - y = 64'hBE365DEBD46ECD4E; - zrf = 64'hBF4FFF0FFFFFFFFE; - ans = 64'hC1865DEBEACEBBDC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1057307\n"); - end - xrf = 64'h380FFBFFFFF7FFFE; - y = 64'h3FD0000000000001; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h37EFFBFFFFF80000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1057921\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h3DFFFFF7FFFFFF7E; - zrf = 64'h7FD0000000000001; - ans = 64'h7FD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1058535\n"); - end - xrf = 64'h3F5007FFFFFFFF80; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h3C71FFFFFFFEFFFE; - ans = 64'h3F4008000000000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1059149\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hB7F00002001FFFFF; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1059763\n"); - end - xrf = 64'h480FFFFFFFFFF83F; - y = 64'hBF2FFFFFFFFFFFFE; - zrf = 64'h802FFFFFFFF801FF; - ans = 64'hC74FFFFFFFFFF83D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1060377\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h3FE0000000000001; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1060991\n"); - end - xrf = 64'h407BFFFFFFDFFFFE; - y = 64'hD3CFFFC000000080; - zrf = 64'h3FF0000000000000; - ans = 64'hD45BFFC7FFE000AE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1061605\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h43CABC69886420B5; - ans = 64'h43CABC69886420B5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1062219\n"); - end - xrf = 64'h801013FFFFFFFFFF; - y = 64'hB28C5CC5F8E8D925; - zrf = 64'hBFD01FFFFFFFFEFE; - ans = 64'hBFD01FFFFFFFFEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1062833\n"); - end - xrf = 64'h4031001FFFFFFFFE; - y = 64'h3FF0000000000000; - zrf = 64'h8010000000000000; - ans = 64'h4031001FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1063447\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hC000000010400000; - zrf = 64'h48040000000FFFFE; - ans = 64'h48040000000FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1064061\n"); - end - xrf = 64'hC3CFFFFF7FFFF800; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hC34000040000003F; - ans = 64'hC3E003FFC0FFFC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1064675\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hC1C0400002000000; - zrf = 64'hC340000000000000; - ans = 64'hC340000008200001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1065289\n"); - end - xrf = 64'hC800F8701DDBAD16; - y = 64'hC7E0000001FFFFF7; - zrf = 64'h3270003FFFDFFFFF; - ans = 64'h4FF0F8701FFABB10; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1065903\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h4000000000000000; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1066517\n"); - end - xrf = 64'hFFE0000000BFFFFF; - y = 64'h47EFFEFF7FFFFFFF; - zrf = 64'h3FE0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1067131\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h4000000000000001; - zrf = 64'h3F5FFFF7FFFC0000; - ans = 64'h3FF007FFFDFFFF00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1067745\n"); - end - xrf = 64'h4035C9DBE1FE4CF2; - y = 64'h41EFFFF7FFFFFFFE; - zrf = 64'h3F8FFFFDFFFDFFFF; - ans = 64'h4235C9D66F875871; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1068359\n"); - end - xrf = 64'h802000007FFFFFBF; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h8000000000000001; - ans = 64'h804000007FFFFFBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1068973\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h401B82AFA2781976; - zrf = 64'h43C203FFFFFFFFFF; - ans = 64'h43C203FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1069587\n"); - end - xrf = 64'hC1CFFFFFFFF00001; - y = 64'h4010000000000001; - zrf = 64'h1C2B3ED2326B0A9D; - ans = 64'hC1EFFFFFFFF00003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1070201\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hC1EFFBFFFFFFFFF7; - zrf = 64'hC010000000000001; - ans = 64'hC1DFFC0000FFFFF5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1070815\n"); - end - xrf = 64'h4341FFFFFFFFFF00; - y = 64'h41B0000102000000; - zrf = 64'h3FA2FCF93281DA50; - ans = 64'h45020001223FFF00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1071429\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1072043\n"); - end - xrf = 64'hB7E0000FFFEFFFFF; - y = 64'hC0075D6CD888AC6C; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1072657\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h4340000000000000; - zrf = 64'h381B3756C7E0CEA2; - ans = 64'h432FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1073271\n"); - end - xrf = 64'hC7FFFF000001FFFE; - y = 64'hBFF0000100001FFF; - zrf = 64'h43C00000800FFFFF; - ans = 64'h47FFFF01FFF23FFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1073885\n"); - end - xrf = 64'h3FB00000001FBFFF; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1074499\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h80100000103FFFFF; - zrf = 64'h4030000010000003; - ans = 64'h4030000010000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1075113\n"); - end - xrf = 64'h20200003FFFFFBFF; - y = 64'h7FE0000000000000; - zrf = 64'hC50CBDCA372F5092; - ans = 64'h60100003FFFFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1075727\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hB7EF8000007FFFFF; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1076341\n"); - end - xrf = 64'h800E082148C2033E; - y = 64'h403604647E01C31D; - zrf = 64'h43E55C3E9937D71C; - ans = 64'h43E55C3E9937D71C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1076955\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h7FDFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1077569\n"); - end - xrf = 64'h43EEFF0000000000; - y = 64'h7FFDE1631284A2C5; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h7FFDE1631284A2C5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1078183\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hBFD000001000001F; - ans = 64'h7FDFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1078797\n"); - end - xrf = 64'h400A5BB8D30DC2EF; - y = 64'h4110007FFFFFE000; - zrf = 64'hC00FFFFE0FFFFFFF; - ans = 64'h412A5C83B0D4A2A6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1079411\n"); - end - xrf = 64'h402FFF7FFF7FFFFF; - y = 64'h7FF0000000000001; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1080025\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hC1C043520BF4D23A; - zrf = 64'h31500000000001F7; - ans = 64'hC1B043520BF4D239; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1080639\n"); - end - xrf = 64'h403FFFFFE0200000; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h477FFFFFDFFFBFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1081253\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hC1EFFFFFFBFFFF7F; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hC1DFFFFFFC7FFF7D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1081867\n"); - end - xrf = 64'hC1EE9E66872FC38D; - y = 64'h36C98C27589707B2; - zrf = 64'hD498E3DB9F1B5795; - ans = 64'hD498E3DB9F1B5795; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1082481\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h8000000000000001; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1083095\n"); - end - xrf = 64'hC037A9075979CBC4; - y = 64'h40518D2E789419D0; - zrf = 64'h3CA0000000000000; - ans = 64'hC099F45E1819C3E1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1083709\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hBF8000002000000F; - ans = 64'hBF8000002000000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1084323\n"); - end - xrf = 64'hBFCFF0000003FFFF; - y = 64'hFFDFF7FFFFFFF000; - zrf = 64'h3D0FE000001FFFFF; - ans = 64'h7FBFE8040003EF07; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1084937\n"); - end - xrf = 64'hBFC8A912FAE0FC93; - y = 64'h8010000000000000; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1085551\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h3FEFFFBFF0000000; - zrf = 64'h41C2406AD1F3DEA0; - ans = 64'h41C2406AD233DE20; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1086165\n"); - end - xrf = 64'hB7F4FFFFFFFFFFFE; - y = 64'h8010000000000001; - zrf = 64'hC1C00000000400FF; - ans = 64'hC1C00000000400FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1086779\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h40500000001FBFFE; - zrf = 64'hBFF0000000000000; - ans = 64'h403F0000003F7FFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1087393\n"); - end - xrf = 64'hBFB39DB3C745AB05; - y = 64'hC28FFFFFFFFFDFE0; - zrf = 64'hBDEFFFFFFC000800; - ans = 64'h42539DB3C7459754; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1088007\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hBCA0000000000000; - zrf = 64'h4000000000000000; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1088621\n"); - end - xrf = 64'hABCB70E42BF56E97; - y = 64'h43CFFF00000001FF; - zrf = 64'h0010000000000001; - ans = 64'hAFAB7008A4D410A2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1089235\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hBCA0000000000001; - zrf = 64'h3FE0000013FFFFFF; - ans = 64'h3FE0000013FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1089849\n"); - end - xrf = 64'hC4D03FFFFFFFFFFF; - y = 64'hE2387F5A30B75DCE; - zrf = 64'hC030FFFFFFFFFFDF; - ans = 64'h6718E157997A3B44; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1090463\n"); - end - xrf = 64'hC1CFFFFFF7FFFFF7; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1091077\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hC7FFFFFFC000007F; - zrf = 64'hBFF4FFFFFFFFFFFF; - ans = 64'hC7EFFFFFC000007D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1091691\n"); - end - xrf = 64'h37500007FFFEFFFF; - y = 64'hBFD0000000000000; - zrf = 64'h000FFFFFF800007F; - ans = 64'hB7300007FFFEFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1092305\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h5E30FFF000000000; - zrf = 64'hBFE0000000000001; - ans = 64'h5E20FFEFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1092919\n"); - end - xrf = 64'hC9E919F45AC84E5F; - y = 64'hBF00004000002000; - zrf = 64'h3FAFFFC100000000; - ans = 64'h48F91A58C299EBB4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1093533\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h3FF0000000000001; - ans = 64'h3FE8000000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1094147\n"); - end - xrf = 64'h47F0000000000DFF; - y = 64'h381FFC000000001E; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h401FFC0000001C19; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1094761\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hBFE0000000000000; - zrf = 64'hC4DFFFFFDFBFFFFE; - ans = 64'hC4DFFFFFDFBFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1095375\n"); - end - xrf = 64'h3FD3AD346C33E68E; - y = 64'hC1051C2D00B3BF05; - zrf = 64'h3FDFFFEFFFFF7FFF; - ans = 64'hC0E9F5EB41C9F664; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1095989\n"); - end - xrf = 64'hC3F27A392E74EC3D; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h43F27A392E74EC3C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1096603\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h381FFFFFFFFF8100; - zrf = 64'hC01FFFFFFFEFC000; - ans = 64'hC01FFFFFFFEFC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1097217\n"); - end - xrf = 64'hC09FFEFFFFFFFFBF; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hC0145E9928594298; - ans = 64'h409FEAA166D7A67A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1097831\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h43DFF00000000003; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'h43CFF00000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1098445\n"); - end - xrf = 64'hBFFFFFE000000003; - y = 64'h3F0C000001FFFFFF; - zrf = 64'h5B60000000000100; - ans = 64'h5B60000000000100; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1099059\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1099673\n"); - end - xrf = 64'hAC0F800000000001; - y = 64'hFFFFFFFFFDFFFFFB; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1100287\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h41FFFFFFFEFFF7FE; - ans = 64'h41FFFFFFFEEFF7FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1100901\n"); - end - xrf = 64'hC4D21A55752A67B8; - y = 64'h3DABFFEFFFFFFFFF; - zrf = 64'hBE0FFFE0000FFFFF; - ans = 64'hC28FAE0372B4C056; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1101515\n"); - end - xrf = 64'hBFD0000000000EFF; - y = 64'hC000000000000001; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h40120000000001DF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1102129\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hFFF4E88B301CCC49; - zrf = 64'h41CFFFFFEFFFEFFF; - ans = 64'hFFFCE88B301CCC49; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1102743\n"); - end - xrf = 64'hC3DFFFF0000FFFFE; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h3800007FFFFFFFC0; - ans = 64'h43FFFFF0000FFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1103357\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hC03FFFFF7FDFFFFE; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hC02FFFFF7FDFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1103971\n"); - end - xrf = 64'hC7FFFFFFFB7FFFFF; - y = 64'h37EFFFFFFFDFFBFF; - zrf = 64'hC34000003FFFFFFC; - ans = 64'hC34000003FFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1104585\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hC010000000000001; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'hBFF8000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1105199\n"); - end - xrf = 64'h40F01FFFFFFFFFF6; - y = 64'hB7FEFFFF7FFFFFFE; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1105813\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h400E000000000000; - ans = 64'hBFCFFFFFFFFFFFD0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1106427\n"); - end - xrf = 64'h002FFFFFFF700000; - y = 64'hB7EFFFFFFFFFDFBF; - zrf = 64'hB7FB7132663A42B2; - ans = 64'hB7FB7132663A42B2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1107041\n"); - end - xrf = 64'hBFD0008000003FFE; - y = 64'hC340000000000000; - zrf = 64'h4000000000000000; - ans = 64'h4320008000004002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1107655\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h3E1FFFFFFEFFF000; - zrf = 64'h3FEFDFFFFFFFFFFF; - ans = 64'h3FEFE000007FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1108269\n"); - end - xrf = 64'hEAF000000000FFDF; - y = 64'hC340000000000001; - zrf = 64'hBF4000000023FFFE; - ans = 64'h6E4000000000FFE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1108883\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'h41F00007FFF7FFFE; - zrf = 64'hBCA0000000000000; - ans = 64'h41E00007FFF7FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1109497\n"); - end - xrf = 64'h802FFFFFFF7FFC00; - y = 64'hBA003FFFFE000000; - zrf = 64'h41F5E9BB04770872; - ans = 64'h41F5E9BB04770872; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1110111\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hFFE0000000000000; - zrf = 64'h3FD0000000000000; - ans = 64'hFFCFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1110725\n"); - end - xrf = 64'hC3EFFFFFDFC00000; - y = 64'hC0388527EF25A62F; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1111339\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hFFE0000000000001; - zrf = 64'hC0507FFFFFFFF800; - ans = 64'hFFD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1111953\n"); - end - xrf = 64'h3F2000100FFFFFFF; - y = 64'hB80FFFFFFFF80100; - zrf = 64'hCBC0000010010000; - ans = 64'hCBC0000010010000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1112567\n"); - end - xrf = 64'h2FC3FEE42A17A068; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h3FF0000000000001; - ans = 64'hEFC3FEE42A17A067; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1113181\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hAC886013D8702B8D; - zrf = 64'h7FF0001FFFE00000; - ans = 64'h7FF8001FFFE00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1113795\n"); - end - xrf = 64'hC3FFFFFFFFFFFFFF; - y = 64'hFFF0000000000000; - zrf = 64'h54BEFFFF7FFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1114409\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hC7F1FFFF80000000; - zrf = 64'h8010000000000001; - ans = 64'hC7E1FFFF7FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1115023\n"); - end - xrf = 64'h40200003FFFFDFFF; - y = 64'hB1407FFFFFEFFFFF; - zrf = 64'hC02008000000003F; - ans = 64'hC02008000000003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1115637\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFE; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h3CA0000000000001; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1116251\n"); - end - xrf = 64'hBE62C38E424FE361; - y = 64'h412FFFBFFFFFFFBE; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1116865\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h0000000000000000; - zrf = 64'h000F7FFFBFFFFFFF; - ans = 64'h000F7FFFBFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1117479\n"); - end - xrf = 64'hC80FFFFF7FFFFFDF; - y = 64'h227C56AAB6DA3602; - zrf = 64'h94B4858BCE164D6E; - ans = 64'hAA9C56AA457F8B09; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1118093\n"); - end - xrf = 64'h43D03FFFFEFFFFFE; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1118707\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hBFEFFFFFF8020000; - zrf = 64'h41EAECD3F27183B9; - ans = 64'h41EAECD3F26183B9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1119321\n"); - end - xrf = 64'h46CFFFFFF7FFFFFF; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h55FFFFFFFFFFF002; - ans = 64'h55FFFFFFFFFFF002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1119935\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hBFBFFE07FFFFFFFF; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'hBFAFFE07FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1120549\n"); - end - xrf = 64'h418FFFFFFFFC0100; - y = 64'h41C001FFFFDFFFFF; - zrf = 64'h7DB000800007FFFE; - ans = 64'h7DB000800007FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1121163\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h0027FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1121777\n"); - end - xrf = 64'hC7FE000400000000; - y = 64'h3FF20000000007FF; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC800E0024000077F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1122391\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hC1F3FF7FFFFFFFFF; - ans = 64'hC1F3FF7FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1123005\n"); - end - xrf = 64'hC0300FFFFFFFFFFD; - y = 64'h3FB03FFFFFFF7FFE; - zrf = 64'hFFD0001FFFFFFF7E; - ans = 64'hFFD0001FFFFFFF7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1123619\n"); - end - xrf = 64'h40EFFFEFFFFFFDFF; - y = 64'h3CA0000000000001; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FE000000000FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1124233\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h415FFFF004000000; - zrf = 64'h41FEFFFFFFFFEFFF; - ans = 64'h41FF03FFFE006FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1124847\n"); - end - xrf = 64'h6AFFFFFFFFFDDFFF; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h3FCFFFC01FFFFFFF; - ans = 64'h67BFFFFFFFFDDFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1125461\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hC06000000000006F; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1126075\n"); - end - xrf = 64'hBF4F800000000006; - y = 64'hBF800003FFBFFFFF; - zrf = 64'h550E46264996A342; - ans = 64'h550E46264996A342; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1126689\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h3FD0000000000001; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h3FC0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1127303\n"); - end - xrf = 64'hBCAFFF7FBFFFFFFF; - y = 64'hBF8FFFFFFFFFE7FF; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1127917\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h3CAEFFFFF7FFFFFF; - ans = 64'h3FD0000000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1128531\n"); - end - xrf = 64'hC0F2269EA37979B7; - y = 64'hC3E5044465ED15FE; - zrf = 64'h99006FFFFFFFFFFE; - ans = 64'h44E7D78775FB434B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1129145\n"); - end - xrf = 64'hBDAFFFFFBFFFFFC0; - y = 64'h3FE0000000000000; - zrf = 64'h3FD0000000000000; - ans = 64'h3FCFFFFFFFFC0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1129759\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hC02FBFFFFFFFFC00; - zrf = 64'hBF4FFFFFFC080000; - ans = 64'hC01FC0FFFFFFDC40; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1130373\n"); - end - xrf = 64'h43C4B497E002A189; - y = 64'h3FE0000000000001; - zrf = 64'h3FB00000013FFFFF; - ans = 64'h43B4B497E002A18A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1130987\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hBA8FDFFFFFFFF7FF; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1131601\n"); - end - xrf = 64'hC05007F800000000; - y = 64'h7FD0010000000007; - zrf = 64'h3DCE087CDC3EE03D; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1132215\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h3FF0000000000000; - zrf = 64'h0000000000000000; - ans = 64'h3FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1132829\n"); - end - xrf = 64'h40100000000040FF; - y = 64'h40382A63E3DB7F32; - zrf = 64'hC000000000000001; - ans = 64'h4057AA63E3DBE15D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1133443\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h3FF0000000000001; - zrf = 64'h403BFF7FFFFFFFFE; - ans = 64'h403C7F7FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1134057\n"); - end - xrf = 64'hCCEFFFFFDFF7FFFF; - y = 64'h1B3C000000003FFE; - zrf = 64'hC3E000007FFBFFFE; - ans = 64'hC3E000007FFBFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1134671\n"); - end - xrf = 64'h4420003FFFFF8000; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h3CA0000000000001; - ans = 64'h4430003FFFFF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1135285\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h380FFFFFFD7FFFFE; - zrf = 64'hBFEFBFFFFFFFFFF0; - ans = 64'hBFEFBFFFFFFFFFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1135899\n"); - end - xrf = 64'h41EC9BDA337E16AB; - y = 64'h4000000000000000; - zrf = 64'hB50FFFFFFFFEFFEE; - ans = 64'h41FC9BDA337E16AB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1136513\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hA6741A0E20872621; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1137127\n"); - end - xrf = 64'h5FA00000010000FF; - y = 64'hC000000003FFFDFE; - zrf = 64'h3CC7741A54494340; - ans = 64'hDFB0000004FFFEFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1137741\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1138355\n"); - end - xrf = 64'hBFE7198953B924E4; - y = 64'h19E201FFFFFFFFFE; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1138969\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h4010000000000000; - zrf = 64'h3FDFBFFFFFFEFFFF; - ans = 64'h4003F7FFFFFFE000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1139583\n"); - end - xrf = 64'h7FE00000003FFFEE; - y = 64'hC6A01000000007FE; - zrf = 64'h386001000FFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1140197\n"); - end - xrf = 64'h41CC0C7A32611D71; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h41FC0C7A32611D70; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1140811\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hC1FFFFFF000001FF; - zrf = 64'h800FFFFFFFFFFDDE; - ans = 64'hC1EFFFFF000001FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1141425\n"); - end - xrf = 64'h402FFFFFFF7F7FFE; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h801FFFEFFFFFFE00; - ans = 64'h405FFFFFFF7F7FFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1142039\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hE0600007FFFFFC00; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'hE0500007FFFFFC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1142653\n"); - end - xrf = 64'h42CBB2BFC8A9AB72; - y = 64'hFFEFFFFFF800001E; - zrf = 64'hC3D1FFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1143267\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h4340000000000001; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1143881\n"); - end - xrf = 64'h800A63B087D63021; - y = 64'h42DFFFFFFDFFFC00; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hBFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1144495\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h4A2FFFFFFFDFFFFF; - ans = 64'h4A2FFFFFFFDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1145109\n"); - end - xrf = 64'h42EA28F2F54C20DD; - y = 64'hBFDFFFEFF0000000; - zrf = 64'h3F6FFFFFFE1FFFFF; - ans = 64'hC2DA28E5D3BE2CBC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1145723\n"); - end - xrf = 64'h401FFFFBFFFFFF7F; - y = 64'h7FE0000000000001; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1146337\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h40FAA9DBBA56F555; - zrf = 64'h45100000400003FF; - ans = 64'h45100000400003FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1146951\n"); - end - xrf = 64'h3A3FFF8000007FFF; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h400FFBFFFFFFFFBF; - ans = 64'h7A3FFF8000007FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1147565\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hC7E0004003FFFFFE; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'hC7D0004003FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1148179\n"); - end - xrf = 64'h43F027459B92631B; - y = 64'hC060000200000003; - zrf = 64'h43E0000012000000; - ans = 64'hC4601747A0691690; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1148793\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h7FF0000000000000; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1149407\n"); - end - xrf = 64'hC1DFE00000000001; - y = 64'h37FFFFFFFBFFBFFE; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1150021\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h37EFFC00007FFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1150635\n"); - end - xrf = 64'h418FC8D90993BDBB; - y = 64'h46AFFFDFFFFEFFFF; - zrf = 64'h404B2AA5588E3698; - ans = 64'h484FC8B940B9B5DF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1151249\n"); - end - xrf = 64'h3F35B1AD19CCBB88; - y = 64'h8000000000000000; - zrf = 64'h0000000000000000; - ans = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1151863\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h41CFFFFEFFFFC000; - zrf = 64'hC7E00000008FFFFF; - ans = 64'hC7E00000008FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1152477\n"); - end - xrf = 64'h3FCFF0000000007F; - y = 64'h8000000000000001; - zrf = 64'h4024D806BCE3C412; - ans = 64'h4024D806BCE3C412; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1153091\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hC310000043FFFFFE; - zrf = 64'h4010000000000000; - ans = 64'hC300000043FFFFDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1153705\n"); - end - xrf = 64'h22973342C2D94245; - y = 64'hBC5000007FFFFF00; - zrf = 64'h3FD000FFFFFFFF7E; - ans = 64'h3FD000FFFFFFFF7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1154319\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1154933\n"); - end - xrf = 64'hBFB60F9E9B37FF4D; - y = 64'hBE9007FFFFFFFBFF; - zrf = 64'hBFD0000000000001; - ans = 64'hBFCFFFFFD3CAB32D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1155547\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h8010000000000001; - zrf = 64'h7FF0000000000023; - ans = 64'h7FF8000000000023; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1156161\n"); - end - xrf = 64'hBF600000000001FF; - y = 64'h401E1107EFF9A8DC; - zrf = 64'hCFC0FE0000000000; - ans = 64'hCFC0FE0000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1156775\n"); - end - xrf = 64'hC383A01B0A54CF13; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1157389\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hC3E89E6D0A424544; - zrf = 64'h000053D77B90F71D; - ans = 64'hC3D89E6D0A424544; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1158003\n"); - end - xrf = 64'hC1FFFFFFDF800000; - y = 64'hBCA0000000000000; - zrf = 64'hBDF0200000003FFE; - ans = 64'h3EAFFDFBDF7FFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1158617\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hC3C0000001DFFFFF; - zrf = 64'h4000000000000001; - ans = 64'hC3B0000001DFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1159231\n"); - end - xrf = 64'hC34FFFFFFFFF87FE; - y = 64'h41EFFFFFFFF003FF; - zrf = 64'h105000004000000F; - ans = 64'hC54FFFFFFFEF8BFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1159845\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'hC010000000000001; - ans = 64'hC010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1160459\n"); - end - xrf = 64'hC3E00000005FFFFF; - y = 64'h8C5001FFFFFFBFFF; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1161073\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hBFD0000000000000; - zrf = 64'hC7FFFFFBFDFFFFFF; - ans = 64'hC7FFFFFBFDFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1161687\n"); - end - xrf = 64'h490723EB06262E31; - y = 64'hFD18000000FFFFFF; - zrf = 64'h3C1000004000FFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1162301\n"); - end - xrf = 64'hB7EFFFFFFBFFF800; - y = 64'hBFD0000000000001; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1162915\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hC7F02007FFFFFFFE; - zrf = 64'hBB5605238E05DFBA; - ans = 64'hC7E02007FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1163529\n"); - end - xrf = 64'h7FFFFFFFF7FFFFFA; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h318E000004000000; - ans = 64'h7FFFFFFFF7FFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1164143\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hC0353E5BC7EF131D; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'hC0213E5BC7EF131D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1164757\n"); - end - xrf = 64'hC3400040000003FE; - y = 64'hC03FE00000100000; - zrf = 64'h3FF494F28DCAC0D3; - ans = 64'h438FE07F80100834; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1165371\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hBFE0000000000001; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC011000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1165985\n"); - end - xrf = 64'hC3EFFFFFFFE003FF; - y = 64'hC21FBFFFFFDFFFFE; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h461FBFFFFFC043F5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1166599\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h434FFFFF1FFFFFFF; - ans = 64'h434FFFFF1FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1167213\n"); - end - xrf = 64'h3E10000207FFFFFF; - y = 64'hC5C185538585F023; - zrf = 64'h7FD0000FFFFFBFFF; - ans = 64'h7FD0000FFFFFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1167827\n"); - end - xrf = 64'h800FFFFFFDFFFFFF; - y = 64'hBFF0000000000000; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1168441\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hC1CFFFFFFFF7FFDF; - zrf = 64'hC01000000003FFFB; - ans = 64'hC1C0000001FBFFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1169055\n"); - end - xrf = 64'h9D9000000000407F; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h3FC000800000FFFF; - ans = 64'h3FC000800000FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1169669\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h4163FFFFFFFFFFBE; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h415400003FFFFFBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1170283\n"); - end - xrf = 64'hC03FFFFFFFFF7EFE; - y = 64'h381EFFFFFFFFFF7E; - zrf = 64'h3FE800001FFFFFFF; - ans = 64'h3FE800001FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1170897\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hC000000000000000; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hC007FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1171511\n"); - end - xrf = 64'h3FFB431B34B7CE0C; - y = 64'hC7F000000003FFFC; - zrf = 64'h8010000000000000; - ans = 64'hC7FB431B34BE9ECC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1172125\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'hC1F25D65F88033E0; - ans = 64'hC1F25D65F8A033E0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1172739\n"); - end - xrf = 64'h800FEEFFFFFFFFFF; - y = 64'h7FD1FFFFFFFFFFF6; - zrf = 64'hBF70000000003FBE; - ans = 64'hBFF1FCE000000035; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1173353\n"); - end - xrf = 64'h09C0200002000000; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1173967\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h4010000000801FFF; - zrf = 64'hBFAFFFC800000000; - ans = 64'h3FFF0001C1003FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1174581\n"); - end - xrf = 64'hC1C581FBC774F374; - y = 64'hC010000000000001; - zrf = 64'hC00FFFF3FFFFFFFE; - ans = 64'h41E581FBC6F4F3A5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1175195\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h3BFFFFFFFFFFF6FF; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1175809\n"); - end - xrf = 64'h37FBD52CF116FCB7; - y = 64'h3FC8800000000000; - zrf = 64'h43F0FFFFFFFFFFFE; - ans = 64'h43F0FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1176423\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hBFF0000000000000; - ans = 64'hC013FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1177037\n"); - end - xrf = 64'h400FFFFFEFFFFFFB; - y = 64'hAAF0C734E2A389B1; - zrf = 64'h8000000000000001; - ans = 64'hAB10C734DA3FEF3D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1177651\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hC340000000000001; - zrf = 64'h5C37AF0E6B6739FF; - ans = 64'h5C37AF0E6B6739FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1178265\n"); - end - xrf = 64'hB7EFFFF80000000F; - y = 64'hDD90000020000007; - zrf = 64'hB80B36A0270E1A29; - ans = 64'h558FFFF83FFFF01D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1178879\n"); - end - xrf = 64'hBE97FFFFFFFFFFFC; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hC010000000000001; - ans = 64'h41F7FFFFFFBFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1179493\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h4800001FFFFFFFFE; - zrf = 64'h72E0000010000000; - ans = 64'h72E0000010000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1180107\n"); - end - xrf = 64'hC05000403FFFFFFF; - y = 64'hFFE0000000000000; - zrf = 64'h397EBF9F5C9C83E9; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1180721\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h0B9CBD5808FDB0FE; - zrf = 64'h3FD0000000000001; - ans = 64'h3FD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1181335\n"); - end - xrf = 64'hBFF9104A39BDD7BB; - y = 64'h3FFEFFFFEFFFFFFF; - zrf = 64'h4020000FFFFFFFF0; - ans = 64'h4013DC3C124C1DF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1181949\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hBFE0000000000001; - ans = 64'hFFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1182563\n"); - end - xrf = 64'hC1901FFBFFFFFFFE; - y = 64'h3CF010001FFFFFFF; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1183177\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'hFFF0000000000000; - zrf = 64'hBFCCA72E89F506ED; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1183791\n"); - end - xrf = 64'h000020000000001E; - y = 64'hD9AFFFFFFFEFFFDE; - zrf = 64'h3FB1000000008000; - ans = 64'h3FB1000000008000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1184405\n"); - end - xrf = 64'h41F89968EBD9BC5C; - y = 64'hFFF0000000000001; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1185019\n"); - end - xrf = 64'h3FE0000000000000; - y = 64'h43D1CCF3DD115F1B; - zrf = 64'h4000100003FFFFFF; - ans = 64'h43C1CCF3DD115F1B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1185633\n"); - end - xrf = 64'h801DFFFFFFFF7FFE; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h002E0001FFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1186247\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'hB81FFFFFF7FE0000; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1186861\n"); - end - xrf = 64'hBFD0000000000100; - y = 64'h43400000000007FE; - zrf = 64'hBF80200007FFFFFF; - ans = 64'hC3200000000008FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1187475\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h0000000000000001; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1188089\n"); - end - xrf = 64'hC1E7433321AAB73A; - y = 64'hC20007FFFFFFFFE0; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1188703\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h3CAFF0000000003F; - ans = 64'h3CAFF0000000003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1189317\n"); - end - xrf = 64'h43D00004000003FE; - y = 64'h8D00800000000000; - zrf = 64'h775FFFFFF7FFFF7F; - ans = 64'h775FFFFFF7FFFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1189931\n"); - end - xrf = 64'h400FFFFFFFFC0001; - y = 64'h0010000000000000; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hBFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1190545\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h528FFFDFF7FFFFFF; - zrf = 64'h41C0020080000000; - ans = 64'h527FFFDFF8000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1191159\n"); - end - xrf = 64'hD3CFEFFFBFFFFFFF; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hDC7000000000401F; - ans = 64'hDC7000000000401F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1191773\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h2A9C69744FCB1FC1; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h2A8C69744FCB1FC3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1192387\n"); - end - xrf = 64'hC15000000000011F; - y = 64'hC01FF7FFFFFFDFFF; - zrf = 64'hC67FFFFFFFFFFFC8; - ans = 64'hC67FFFFFFFFFFFC8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1193001\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h3CA0000000000000; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hBCA7FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1193615\n"); - end - xrf = 64'hBFDAFBBC119D048E; - y = 64'h41DFFFFC00200000; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1194229\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hC1C0000008000010; - ans = 64'hC1C0000008000010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1194843\n"); - end - xrf = 64'h3F3FFFFFFFC00001; - y = 64'h832FFFFFFFFFF400; - zrf = 64'hB8100001FFFFC000; - ans = 64'hB8100001FFFFC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1195457\n"); - end - xrf = 64'h197FFEFFFFFFEFFF; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'hBFF0000000000000; - ans = 64'hBFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1196071\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h3FCF000000400000; - zrf = 64'h50E00000000000FE; - ans = 64'h50E00000000000FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1196685\n"); - end - xrf = 64'hE7BFFFFC0000007E; - y = 64'h3FD0000000000001; - zrf = 64'hFFFE22D338585265; - ans = 64'hFFFE22D338585265; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1197299\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h001FFFE000001FFF; - zrf = 64'h0010000000000000; - ans = 64'h001FFFF000001000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1197913\n"); - end - xrf = 64'hBFD40000000003FF; - y = 64'hC5B1000001FFFFFF; - zrf = 64'h4050000000FFFDFF; - ans = 64'h459540000280043E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1198527\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'hBCA0000000000000; - ans = 64'h3FCFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1199141\n"); - end - xrf = 64'h410FE00000000001; - y = 64'hB800000047FFFFFF; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1199755\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h3FE0000000000001; - zrf = 64'h40780CC8FBC669E4; - ans = 64'h407810C8FBC669E4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1200369\n"); - end - xrf = 64'h403A681B52736AB4; - y = 64'hB547FFFFFFFFF7FF; - zrf = 64'hBFE0000007FFFFBF; - ans = 64'hBFE0000007FFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1200983\n"); - end - xrf = 64'hFFEFFFFFFFFFF800; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'hBFE0000000000001; - ans = 64'hFFEFFFFFFFFFF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1201597\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h480FFFFFEFFFFFF7; - zrf = 64'hC7F0000000023FFF; - ans = 64'h47EFFFFFDFFB7FF4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1202211\n"); - end - xrf = 64'h802FFFFDFBFFFFFF; - y = 64'h3FF0000000000000; - zrf = 64'hBFFFBFFFFFFBFFFF; - ans = 64'hBFFFBFFFFFFBFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1202825\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h415F94D2F6C29D24; - zrf = 64'h0000000000000001; - ans = 64'h414F94D2F6C29D26; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1203439\n"); - end - xrf = 64'h3FCB3C1786B1DCDD; - y = 64'h40001000000001FF; - zrf = 64'hC01000000203FFFE; - ans = 64'hC00C95159040EDB8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1204053\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h8010000000000001; - ans = 64'h3FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1204667\n"); - end - xrf = 64'hC1F1FFFFFF000000; - y = 64'h3F50040002000000; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'hC152047E013FC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1205281\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h4000000000000000; - zrf = 64'h43FFFFFFFFF01FFE; - ans = 64'h43FFFFFFFFF01FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1205895\n"); - end - xrf = 64'hC030000400100000; - y = 64'hC340001FFFFFFFFE; - zrf = 64'hFFE000003FDFFFFF; - ans = 64'hFFE000003FDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1206509\n"); - end - xrf = 64'hB80000000000081F; - y = 64'h4000000000000001; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1207123\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'hB7E0000000001100; - zrf = 64'h3FD04000000007FF; - ans = 64'h3FD04000000007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1207737\n"); - end - xrf = 64'hC3F0803FFFFFFFFF; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h863FFFFFFEFFFFC0; - ans = 64'hC410803FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1208351\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h40100000041FFFFE; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1208965\n"); - end - xrf = 64'h3FCFAA45B9D49991; - y = 64'h306FDFFFFFFEFFFF; - zrf = 64'h9C3000000000FFFB; - ans = 64'h304F8A9B7419C7A4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1209579\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h4010000000000001; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h4000000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1210193\n"); - end - xrf = 64'hBEFCAD5EA5228D2B; - y = 64'hC3EFFFFFFFFFFFBC; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h42FCAD5EA5228D2E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1210807\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h47F000000040FFFF; - ans = 64'h47F000000040FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1211421\n"); - end - xrf = 64'h434005FFFFFFFFFE; - y = 64'h3FBFFFFFCFFFFFFF; - zrf = 64'h3F5FFFFFFFFFFFCF; - ans = 64'h431005FFE7F6FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1212035\n"); - end - xrf = 64'hC01FFFFF7FFFFFEF; - y = 64'h4340000000000000; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hC36FFFFF7FFFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1212649\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h43FFFFFC00100000; - zrf = 64'hC80A2913FEE53A41; - ans = 64'hC80A2913FEE53A41; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1213263\n"); - end - xrf = 64'h3808F00FB1D7348D; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h43D56A1EBF8784C2; - ans = 64'h43D56A1EBF8784C2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1213877\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h3FF00000FBFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1214491\n"); - end - xrf = 64'h53AFCC613E2DB334; - y = 64'hBFDFE00000001FFF; - zrf = 64'h47F4000200000000; - ans = 64'hD39FAC94DCEFA54C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1215105\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h7FE0000000000000; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1215719\n"); - end - xrf = 64'h3D4BE86A57F38F49; - y = 64'hB7E71747894EDFF3; - zrf = 64'h4000000000000000; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1216333\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h3FEF01FFFFFFFFFE; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1216947\n"); - end - xrf = 64'hC2E000007FFFFFFE; - y = 64'hBFB0000800020000; - zrf = 64'hC7FE0000001FFFFE; - ans = 64'hC7FE0000001FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1217561\n"); - end - xrf = 64'h4A37FFFFBFFFFFFF; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hBCA0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1218175\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h43FF1370D02201AA; - zrf = 64'hC013FFFFFFFFFFFC; - ans = 64'h43EF1370D02201AC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1218789\n"); - end - xrf = 64'hBF6D59563B67BDFB; - y = 64'h7FF0000000000001; - zrf = 64'h401FF8000000FFFF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1219403\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h41F000FFFFFEFFFE; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1220017\n"); - end - xrf = 64'hBE422263AC5FA438; - y = 64'hC0E5FEBF1FFB3F2D; - zrf = 64'h4806E95AD3698BE1; - ans = 64'h4806E95AD3698BE1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1220631\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h7FF0000000000000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1221245\n"); - end - xrf = 64'h37F3488C88AB3C1E; - y = 64'hC0353E87080D3A0F; - zrf = 64'h3FF0000000000001; + z = 64'h3FF0000000000001; ans = 64'h3FF0000000000001; rn = 1; rz = 0; @@ -93541,19 +14955,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -93569,12 +14983,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1221859\n"); + $fwrite(fp,"640451\n"); end - xrf = 64'h3FE0000000000001; - y = 64'h8000000000000001; - zrf = 64'h406987D720CD2CFD; - ans = 64'h406987D720CD2CFD; + x = 64'h3FF00101FFFFFFFF; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hC3FFFFFF00007FFE; + ans = 64'hC3FFFFFF00007FFE; rn = 1; rz = 0; rm = 0; @@ -93588,19 +15002,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -93616,12 +15030,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1222473\n"); + $fwrite(fp,"642465\n"); end - xrf = 64'hFFE0000001FFFEFF; - y = 64'hC0C7FFFFFFFFFFFC; - zrf = 64'h480FF7FFFFFFF7FF; - ans = 64'h7FF0000000000000; + x = 64'h40154B404B0501A2; + y = 64'h380000000003FFFE; + z = 64'hBFEFFEFFFDFFFFFF; + ans = 64'hBFEFFEFFFDFFFFFF; rn = 1; rz = 0; rm = 0; @@ -93635,19 +15049,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -93663,12 +15077,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1223087\n"); + $fwrite(fp,"644479\n"); end - xrf = 64'hBFE00000000EFFFF; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h8010000000000001; - ans = 64'h8007FFFFFFF88002; + x = 64'h3CA0000000000001; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; rn = 1; rz = 0; rm = 0; @@ -93682,19 +15096,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -93710,12 +15124,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1223701\n"); + $fwrite(fp,"646493\n"); end - xrf = 64'h3FE0000000000001; - y = 64'hC6BFFFFBFFFFFFFE; - zrf = 64'h40000FFFFFFFFFEE; - ans = 64'hC6AFFFFC00000000; + x = 64'h58F0000100003FFF; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hB81FFF8000000004; + ans = 64'h5910000100003FFE; rn = 1; rz = 0; rm = 0; @@ -93729,19 +15143,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -93757,12 +15171,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1224315\n"); + $fwrite(fp,"648507\n"); end - xrf = 64'hBA0FFFFE000000FF; - y = 64'h8010000000000000; - zrf = 64'h5730000081FFFFFF; - ans = 64'h5730000081FFFFFF; + x = 64'h001EFF8000000000; + y = 64'h3801AD261B713620; + z = 64'hBEEFFFEFFF000000; + ans = 64'hBEEFFFEFFF000000; rn = 1; rz = 0; rm = 0; @@ -93776,19 +15190,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -93804,716 +15218,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1224929\n"); + $fwrite(fp,"650521\n"); end - xrf = 64'h3FE0000000000001; - y = 64'h37E080000000000F; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1225543\n"); - end - xrf = 64'h7FF000000001FFDF; - y = 64'hAE2FFFF7DFFFFFFE; - zrf = 64'hFFDE52E8C5C19871; - ans = 64'h7FF800000001FFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1226157\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1226771\n"); - end - xrf = 64'h3FB0087FFFFFFFFE; - y = 64'h401009375F1B01C4; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FF4046F11216206; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1227385\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h402FF8001FFFFFFE; - ans = 64'h402FF8001FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1227999\n"); - end - xrf = 64'h43FE00007FFFFFFF; - y = 64'hC3C04000001FFFFF; - zrf = 64'h801000FFC0000000; - ans = 64'hC7CE7800823BFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1228613\n"); - end - xrf = 64'hB80C2C93CB9EB3AC; - y = 64'hBCA0000000000001; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h34BC2C93CB9EB3AE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1229227\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'hC3FFFE000FFFFFFE; - zrf = 64'hB810000000000000; - ans = 64'hC3EFFE0010000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1229841\n"); - end - xrf = 64'h4090000000220000; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hC000000800000008; - ans = 64'hC000000800000208; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1230455\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'h47F0000020001000; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'h47E0000020001001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1231069\n"); - end - xrf = 64'hB8007FFFFFFFBFFF; - y = 64'hC07FFFF80000000F; - zrf = 64'h41E7FFFFFFFFDFFF; - ans = 64'h41E7FFFFFFFFDFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1231683\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'hBFD0000000000001; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1232297\n"); - end - xrf = 64'hC1E28F5AA84A2661; - y = 64'h408CC4DF0D0607D2; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'hC280AF9EBD1524C3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1232911\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h4D3BE3F191496943; - ans = 64'h4D3BE3F191496943; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1233525\n"); - end - xrf = 64'hC1CFFFFFFFFF5FFF; - y = 64'h37F05C7808D8323D; - zrf = 64'h402DB1C05FC1A8CE; - ans = 64'h402DB1C05FC1A8CE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1234139\n"); - end - xrf = 64'hFFEFF7F7FFFFFFFE; - y = 64'hBFE0000000000000; - zrf = 64'h7FFFFFFFFFFFFFFE; + x = 64'h3CA0000000000001; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -94528,19 +15237,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -94556,12 +15265,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1234753\n"); + $fwrite(fp,"652535\n"); end - xrf = 64'h3FE0000000000001; - y = 64'hB80000001FFFBFFE; - zrf = 64'h7FBDDD0E62681E3C; - ans = 64'h7FBDDD0E62681E3C; + x = 64'hC5B00000000FFFFD; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h47DDFFFFFFFFDFFF; + ans = 64'hC90FFFFC401FFFF9; rn = 1; rz = 0; rm = 0; @@ -94575,19 +15284,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -94603,11 +15312,13500 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1235367\n"); + $fwrite(fp,"654549\n"); end - xrf = 64'h39260035ABDD89AD; + x = 64'hC7FFD288F3EB4DC5; + y = 64'h480FFFFFFFE00001; + z = 64'h705E000000000000; + ans = 64'h705E000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"656563\n"); + end + x = 64'h3CA0000000000001; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h7CA0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"658577\n"); + end + x = 64'h849FFFFF7FFBFFFF; + y = 64'h7FF0000000000001; + z = 64'h507FFFBE00000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"660591\n"); + end + x = 64'hFFE0000000038000; + y = 64'h3C100007FFFFFFFF; + z = 64'h3FEFFE0003FFFFFE; + ans = 64'hFC00000800038001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"662605\n"); + end + x = 64'h3CA0000000000001; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"664619\n"); + end + x = 64'hBFB83950C7648672; + y = 64'h8010000000000001; + z = 64'hFEDFFFFC003FFFFF; + ans = 64'hFEDFFFFC003FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"666633\n"); + end + x = 64'hC3F0800400000000; + y = 64'h3C8657726912D3F9; + z = 64'h800FFFFFFF9FFFFF; + ans = 64'hC0870A33923804DD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"668647\n"); + end + x = 64'h3CA0000000000001; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"670661\n"); + end + x = 64'hC015256E6A7C8C32; + y = 64'hBFD0000000000000; + z = 64'hB7FFFFE00FFFFFFE; + ans = 64'h3FF5256E6A7C8C32; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"672675\n"); + end + x = 64'hC15001FFFFFEFFFF; + y = 64'h0010000C00000000; + z = 64'h58700000037FFFFE; + ans = 64'h58700000037FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"674689\n"); + end + x = 64'h3CA0000000000001; + y = 64'hBFE0000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"676703\n"); + end + x = 64'h32601FF7FFFFFFFE; + y = 64'hBFF0000000000000; + z = 64'h58800008000001FE; + ans = 64'h58800008000001FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"678717\n"); + end + x = 64'h4073FFFFFFBFFFFF; + y = 64'h4FF96CDBA635E070; + z = 64'h801000807FFFFFFF; + ans = 64'h507FC8128F5DA51C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"680731\n"); + end + x = 64'h3CA0000000000001; + y = 64'hC000000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCC0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"682745\n"); + end + x = 64'hC2E44ABF8AECE4F4; + y = 64'hC010000000000000; + z = 64'h3A000FFE00000000; + ans = 64'h43044ABF8AECE4F4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"684759\n"); + end + x = 64'h3FBFFFFDFFFFFFDF; + y = 64'h409FFFDC00000000; + z = 64'hB13000FFEFFFFFFE; + ans = 64'h406FFFDA00023FDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"686773\n"); + end + x = 64'h3CA0000000000001; + y = 64'hC340000000000001; + z = 64'h3FF0000000000001; + ans = 64'hBCB0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"688787\n"); + end + x = 64'h4027FFFFFF7FFFFE; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h3FF5535DAB32E04B; + ans = 64'hC387FFFFFF7FFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"690801\n"); + end + x = 64'h3FB0000001000004; + y = 64'h8010007EFFFFFFFE; + z = 64'h3FBFFFFBFFFFE000; + ans = 64'h3FBFFFFBFFFFE000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"692815\n"); + end + x = 64'h3CA0000000000001; + y = 64'hFFF0000000000000; + z = 64'hC340000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"694829\n"); + end + x = 64'hC1DC9FA56189CACB; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h801FFFFF00FFFFFF; + 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,"696843\n"); + end + x = 64'hB80AC4A58221FD00; + y = 64'hB80FFFFFFE000004; + z = 64'h401FFFFFFFFFE7FF; + ans = 64'h401FFFFFFFFFE7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"698857\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h0010000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"700871\n"); + end + x = 64'hBCA000008003FFFF; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hB8C000001FFBFFFF; + ans = 64'hB8C000001FFBFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"702885\n"); + end + x = 64'h40AFFFFFFFBEFFFF; + y = 64'hC1F5BB80746EB9E1; + z = 64'h7FD7FFFFFBFFFFFE; + ans = 64'h7FD7FFFFFBFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"704899\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h3FD0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CB3FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"706913\n"); + end + x = 64'hC3E02000000FFFFF; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hC0CFFFFF00008000; + ans = 64'hC3D020000010000E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"708927\n"); + end + x = 64'h3B1001FFFFF7FFFF; + y = 64'hC3EC47DBDB9FC9E2; + z = 64'hC19F80000000001F; + ans = 64'hC19F800000000E45; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"710941\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"712955\n"); + end + x = 64'h43CFFFFFFFFF3FFF; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hBFCBFECEE81F8C27; + ans = 64'h43DFFFFFFFFF3FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"714969\n"); + end + x = 64'h3FC79F966F93CE1B; + y = 64'h403FFFEFEFFFFFFE; + z = 64'hB7F15A82F49DD625; + ans = 64'h40179F8A93F8CB18; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"716983\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"718997\n"); + end + x = 64'hC1DFFFFFEFFFDFFF; + y = 64'h4010000000000001; + z = 64'h43E0004001000000; + ans = 64'h43E0004000C00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"721011\n"); + end + x = 64'h3FDF0E80E74103A1; + y = 64'hFFF000000803FFFE; + z = 64'hC0D7255CF31DB9E1; + ans = 64'hFFF800000803FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"723025\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"725039\n"); + end + x = 64'hC063FFFFBFFFFFFE; + y = 64'h7FE0000000000001; + z = 64'h7FFFFFFFF80001FE; + ans = 64'h7FFFFFFFF80001FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"727053\n"); + end + x = 64'h3F0FFFFFEBFFFFFE; + y = 64'h7FD0000000404000; + z = 64'h7FD0000010200000; + ans = 64'h7FD00040101FD901; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"729067\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"731081\n"); + end + x = 64'h403AB1833690B538; + y = 64'h8000000000000001; + z = 64'h41F12C4895209B98; + ans = 64'h41F12C4895209B98; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"733095\n"); + end + x = 64'h8000000110000000; + y = 64'hC2F0000080200000; + z = 64'h400FBFFFFFFFDFFF; + ans = 64'h400FBFFFFFFFDFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"735109\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"737123\n"); + end + x = 64'h38C000FFFFFFFFF6; + y = 64'hBCA0000000000000; + z = 64'h37E76291995D8252; + ans = 64'h37E76291995D6250; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"739137\n"); + end + x = 64'hFFE03FFFFBFFFFFF; + y = 64'hBCD3CB8B7F735D5B; + z = 64'hC3E03FFFEFFFFFFF; + ans = 64'h7CC41AB9A87E47EF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"741151\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hBFD0000000000001; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"743165\n"); + end + x = 64'h37FFC3CD8026EDA0; + y = 64'hBFE0000000000000; + z = 64'hBEAB43550AFC66D5; + ans = 64'hBEAB43550AFC66D5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"745179\n"); + end + x = 64'h3CAF0000007FFFFF; + y = 64'h43C3BA241E9C39CF; + z = 64'h43EFEFFDFFFFFFFF; + ans = 64'h43EFEFFDFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"747193\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hBFF0000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"749207\n"); + end + x = 64'hBFAFFFFDFFFFFEFF; + y = 64'hC000000000000000; + z = 64'h3F4000080000001F; + ans = 64'h3FC00FFF07FFFF80; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"751221\n"); + end + x = 64'h00205BF15AD11CA4; + y = 64'hC051FFFFFFBFFFFE; + z = 64'hBFBFDFFFFFFFDFFE; + ans = 64'hBFBFDFFFFFFFDFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"753235\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hC010000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hBCC8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"755249\n"); + end + x = 64'h3FD000000FBFFFFF; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h3FE00000FFFFFEFE; + ans = 64'hBFF7FFFF9F80007D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"757263\n"); + end + x = 64'h412D4A1BE5D5E7E2; + y = 64'hCD600000006FFFFF; + z = 64'h47EFFFFFFF7FFFDF; + ans = 64'hCE9D4A1BE6A2EEA3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"759277\n"); + end + x = 64'h3CAFFFFFFFFFFFFF; + y = 64'hFFE0000000000000; + z = 64'hBFF0000000000001; + ans = 64'hFC9FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"761291\n"); + end + x = 64'hBEC0004000004000; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hBFFC821044378807; + ans = 64'h7EC0004000003FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"763305\n"); + end + x = 64'h8C0FFEFFFFFFFE00; + y = 64'h4360000000FFFFEF; + z = 64'h43F000003FFFFE00; + ans = 64'h43F000003FFFFE00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"765319\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h0000000000000000; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"767333\n"); + end + x = 64'h3FCFFFFF800003FE; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hBFD0000023FFFFFE; + ans = 64'hBFD0000023FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"769347\n"); + end + x = 64'hBFD000080000000F; + y = 64'hB7E1FBFFFFFFFFFF; + z = 64'hB800200000003FFE; + ans = 64'hB7FE007EE0407FFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"771361\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"773375\n"); + end + x = 64'h40192DFAA3A08E50; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hC7E000800003FFFF; + ans = 64'hC7E000800003FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"775389\n"); + end + x = 64'hC040003FFFFBFFFE; + y = 64'hBFC00000009FFFFF; + z = 64'hB97FFFFFFFB00000; + ans = 64'h40100040009C027D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"777403\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCA0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"779417\n"); + end + x = 64'h0020000020010000; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hC1DFFFFFF0100000; + ans = 64'hC1DFFFFFF0100000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"781431\n"); + end + x = 64'hB817A3D74B06DC56; + y = 64'h5650000002000FFF; + z = 64'hBCAF83FFFFFFFFFE; + ans = 64'hCE77A3D74DFB6EE2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"783445\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"785459\n"); + end + x = 64'hB7EFFFFFC07FFFFF; + y = 64'h4000000000000001; + z = 64'h40028B346BBCA5BA; + ans = 64'h40028B346BBCA5BA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"787473\n"); + end + x = 64'h7FDFFFFFEFFFF000; + y = 64'hB7EFFC0000FFFFFF; + z = 64'hA785F7C5BE65AEFC; + ans = 64'hF7DFFBFFF101F000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"789487\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h401FFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"791501\n"); + end + x = 64'h7FD3FFFDFFFFFFFE; + y = 64'h4340000000000001; + z = 64'hC3DD0D539EDF571B; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"793515\n"); + end + x = 64'hB4B6E07873102932; + y = 64'h434FF87FFFFFFFFF; + z = 64'h47E34D80C103EAA3; + ans = 64'h47E34D80C103EAA3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"795529\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"797543\n"); + end + x = 64'h37E000000013FFFE; + y = 64'h7FF0000000000001; + z = 64'hC04D4D91018AB805; + 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,"799557\n"); + end + x = 64'hB802D62C03D44556; + y = 64'h400FFFF87FFFFFFE; + z = 64'hFFEFFFFFC00001FF; + ans = 64'hFFEFFFFFC00001FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"801571\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"803585\n"); + end + x = 64'h405000FFFFFF7FFE; + y = 64'h8010000000000000; + z = 64'h3FBFE00100000000; + ans = 64'h3FBFE00100000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"805599\n"); + end + x = 64'h43E04001FFFFFFFE; + y = 64'hF10581B664845094; + z = 64'h7FE6E21DA5190931; + ans = 64'h7FE6E21DA5190931; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"807613\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hBCA0000000000001; + 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,"809627\n"); + end + x = 64'hBC2080001FFFFFFF; + y = 64'hBFD0000000000000; + z = 64'h41F00007FFFFFFFF; + ans = 64'h41F00007FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"811641\n"); + end + x = 64'hBEF545EA51CB9AAE; + y = 64'hC3C00001FBFFFFFE; + z = 64'hCD90000000207FFF; + ans = 64'hCD90000000207FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"813655\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hBFE0000000000001; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"815669\n"); + end + x = 64'hC00000001FFFBFFF; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h014F01FFFFFFFFFE; + ans = 64'h400000001FFFBFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"817683\n"); + end + x = 64'h4055BD069A83DB81; + y = 64'hBD000006FFFFFFFE; + z = 64'h43F0005FFFFFFFFF; + ans = 64'h43F0005FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"819697\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hC000000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"821711\n"); + end + x = 64'hC7EDFFFFFFFFFBFE; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h7FDF0896F4F2CB64; + ans = 64'h7FDF0896F4F2CB64; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"823725\n"); + end + x = 64'hC3DFFDFF00000000; + y = 64'hC34000FFFFFFFFEF; + z = 64'h381FF7FFF8000000; + ans = 64'h472FFFFEDFEFFFDE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"825739\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hC340000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"827753\n"); + end + x = 64'h3FFB8ACD8E55074B; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h41C3D05E9BB88A09; + ans = 64'hC35B8ACD846CD7FB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"829767\n"); + end + x = 64'hC7F002000000001F; + y = 64'h40BFFF0200000000; + z = 64'h3F6FFFDFFFFDFFFF; + ans = 64'hC8C00180F020001F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"831781\n"); + end + x = 64'h3CAFFFFFFFFFFFFE; + y = 64'hFFF0000000000000; + z = 64'h3FF0000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"833795\n"); + end + x = 64'hC1FF0000000001FF; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h000FFF0008000000; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"835809\n"); + end + x = 64'h3F9FFEFFEFFFFFFF; + y = 64'hFFD0000F80000000; + z = 64'hC1D01000001FFFFF; + ans = 64'hFF7FFF1EEF07F07F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"837823\n"); + end + x = 64'h3FD0000000000000; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"839837\n"); + end + x = 64'h482FFFFFFFFFF3FF; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hBF210000000001FE; + ans = 64'hBF210000000001FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"841851\n"); + end + x = 64'h40056A10A60BBB53; + y = 64'h43FFF7FF7FFFFFFF; + z = 64'h47DFC00003FFFFFF; + ans = 64'h47DFC00003FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"843865\n"); + end + x = 64'h3FD0000000000000; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"845879\n"); + end + x = 64'h00000FF7FFFFFFFF; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h47F000000003FFFC; + ans = 64'h47F000000003FFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"847893\n"); + end + x = 64'hFFDFFFFFBFFFFFFD; + y = 64'h47FFFFFFFFFDFC00; + z = 64'h3FF387DF37B4277C; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"849907\n"); + end + x = 64'h3FD0000000000000; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3FD0000000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"851921\n"); + end + x = 64'h381F000200000000; + y = 64'h3FF0000000000001; + z = 64'h3FDDDE28AA408892; + ans = 64'h3FDDDE28AA408892; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"853935\n"); + end + x = 64'hF4D0700000000000; + y = 64'h4061AE8809F49782; + z = 64'hC3EFFFFFF7FFFF7F; + ans = 64'hF5422A4DC23A47A7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"855949\n"); + end + x = 64'h3FD0000000000000; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hBCB8000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"857963\n"); + end + x = 64'hC3CFFFFFFFFFFFC8; + y = 64'h4010000000000001; + z = 64'hBC12000800000000; + ans = 64'hC3EFFFFFFFFFFFCA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"859977\n"); + end + x = 64'hC300000200007FFE; + y = 64'h473FFDBFFFFFFFFF; + z = 64'hC1EFAE76BD77DB69; + ans = 64'hCA4FFDC3FFB8FFE9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"861991\n"); + end + x = 64'h3FD0000000000000; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h4348000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"864005\n"); + end + x = 64'hC3DC1BC00754990F; + y = 64'h7FE0000000000000; + z = 64'hD87E57C40FADB738; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"866019\n"); + end + x = 64'h4E2C074BC1E14068; + y = 64'h41F007FFFFDFFFFF; + z = 64'hFFEFFFF000003FFF; + ans = 64'hFFEFFFF000003FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"868033\n"); + end + x = 64'h3FD0000000000000; + y = 64'h7FF0000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"870047\n"); + end + x = 64'hC03FFDFFF7FFFFFE; + y = 64'h8000000000000000; + z = 64'hC3FFE01000000000; + ans = 64'hC3FFE01000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"872061\n"); + end + x = 64'h3EDFFFF000001FFF; + y = 64'h41EFEFFDFFFFFFFE; + z = 64'hEB9007FFFFF00000; + ans = 64'hEB9007FFFFF00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"874075\n"); + end + x = 64'h3FD0000000000000; + y = 64'h8010000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"876089\n"); + end + x = 64'hBEC0001FFFFFDFFE; + y = 64'hBCA0000000000000; + z = 64'hC7ECD2B1E4C50852; + ans = 64'hC7ECD2B1E4C50852; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"878103\n"); + end + x = 64'h4030001000000040; + y = 64'h41EFFFFFFFFFFFFF; + z = 64'h42E0000000003FFA; + ans = 64'h42E0020002003FFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"880117\n"); + end + x = 64'h3FD0000000000000; + y = 64'hBFD0000000000001; + z = 64'h3FF0000000000001; + ans = 64'h3FEE000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"882131\n"); + end + x = 64'h4020001000000003; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hBFE007FFFFFFFFBE; + ans = 64'hC012010FFFFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"884145\n"); + end + x = 64'hC3F0FFFFFF7FFFFF; + y = 64'h41FFFEFFFFFFFFFB; + z = 64'hBD9FFFFFFFFFFFDD; + ans = 64'hC600FF77FF8003FC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"886159\n"); + end + x = 64'h3FD0000000000000; + y = 64'hBFF0000000000000; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"888173\n"); + end + x = 64'hC02FFFFFFFFF7FFF; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hBF6FFEFFFFFFFFFC; + ans = 64'h403FFF0007FF7FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"890187\n"); + end + x = 64'hB7F84864126F0E11; + y = 64'hC0EED575F05EAC2D; + z = 64'h9AFFFFF7FFFFFFFF; + ans = 64'h38F765D92A7779A3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"892201\n"); + end + x = 64'h3FD0000000000000; + y = 64'hC010000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"894215\n"); + end + x = 64'h3FF1896CDCA1FBD1; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h802400000FFFFFFF; + ans = 64'hC021896CDCA1FBD0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"896229\n"); + end + x = 64'hA1E0803FFFFFFFFE; + y = 64'hBFCF8000000007FE; + z = 64'h41710F56F6BCE1E1; + ans = 64'h41710F56F6BCE1E1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"898243\n"); + end + x = 64'h3FD0000000000000; + y = 64'hFFE0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hFFC0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"900257\n"); + end + x = 64'hC3400100001FFFFF; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hFFE00FFFFFFFFFBF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"902271\n"); + end + x = 64'h402007FFFFFFFDFE; + y = 64'h40300000000100FF; + z = 64'hC3E0000000000FEF; + ans = 64'hC3E0000000000FEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"904285\n"); + end + x = 64'h3FD0000000000000; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"906299\n"); + end + x = 64'h000000003FEFFFFF; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hC02003FFFFFFFFF7; + ans = 64'hC02003FFFFFFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"908313\n"); + end + x = 64'hC7EFFFF7FFFBFFFF; + y = 64'hC990000004003FFE; + z = 64'hBFFFFFFFFFEFFFC0; + ans = 64'h518FFFF807FC7DFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"910327\n"); + end + x = 64'h3FD0000000000001; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"912341\n"); + end + x = 64'h2E40000800000007; + y = 64'h3CA0000000000001; + z = 64'h537C6525D98B325E; + ans = 64'h537C6525D98B325E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"914355\n"); + end + x = 64'hBFC00000FFFFFE00; + y = 64'h30DFFE0000000007; + z = 64'h3FDFFFF00000FFFE; + ans = 64'h3FDFFFF00000FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"916369\n"); + end + x = 64'h3FD0000000000001; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"918383\n"); + end + x = 64'h30CBFFFFFFFEFFFF; + y = 64'h3FE0000000000001; + z = 64'h43F2000000000004; + ans = 64'h43F2000000000004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"920397\n"); + end + x = 64'h99E5B802C2C594E2; + y = 64'hFFF1FFF7FFFFFFFE; + z = 64'h3FD000000200000F; + ans = 64'hFFF9FFF7FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"922411\n"); + end + x = 64'h3FD0000000000001; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h3FDFFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"924425\n"); + end + x = 64'h3810000040040000; + y = 64'h4000000000000001; + z = 64'hC7EFFFFFFFDEFFFE; + ans = 64'hC7EFFFFFFFDEFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"926439\n"); + end + x = 64'hB7FFFE000000000F; + y = 64'hDE20000000000000; + z = 64'hC34000000020FFFF; + ans = 64'h562FFE000000000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"928453\n"); + end + x = 64'h3FD0000000000001; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'h4008000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"930467\n"); + end + x = 64'hC0958891BB2DE974; + y = 64'h4340000000000000; + z = 64'h7FFF92CC1DBEF0C0; + ans = 64'h7FFF92CC1DBEF0C0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"932481\n"); + end + x = 64'hBFB00FFFFFF00000; + y = 64'h4030000000000810; + z = 64'hC7F0000040000FFF; + ans = 64'hC7F0000040000FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"934495\n"); + end + x = 64'h3FD0000000000001; + y = 64'h7FE0000000000001; + z = 64'hC340000000000000; + ans = 64'h7FC0000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"936509\n"); + end + x = 64'hBFFFFFFFEFFFFBFF; + y = 64'h7FF0000000000000; + z = 64'h001FFFF00000FFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"938523\n"); + end + x = 64'hBEEFFFFFFF800080; + y = 64'h47E000000101FFFF; + z = 64'hDCB000007FFFFFFD; + ans = 64'hDCB000007FFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"940537\n"); + end + x = 64'h3FD0000000000001; + y = 64'h8000000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"942551\n"); + end + x = 64'h41EFFFFFFFFFF840; + y = 64'h8010000000000000; + z = 64'hBFAD057D272190FD; + ans = 64'hBFAD057D272190FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"944565\n"); + end + x = 64'hBFC0001007FFFFFE; + y = 64'hBFD10000000001FF; + z = 64'h99700000013FFFFF; + ans = 64'h3FA10011088001FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"946579\n"); + end + x = 64'h3FD0000000000001; + y = 64'hBCA0000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CABFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"948593\n"); + end + x = 64'h404FFFFDFFFFFFFE; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hC80FFFFFEFFFFFFF; + ans = 64'hC80FFFFFEFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"950607\n"); + end + x = 64'hC3D0002040000000; + y = 64'hC0DD0F3F5E7C7DC9; + z = 64'h7FEDCD8DDF158E1F; + ans = 64'h7FEDCD8DDF158E1F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"952621\n"); + end + x = 64'h3FD0000000000001; + y = 64'hBFE0000000000000; + z = 64'hBFF0000000000001; + ans = 64'hBFF2000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"954635\n"); + end + x = 64'h401FFDFFFFF00000; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hC3400D15CAF2C5CA; + ans = 64'hC3400D15CAF2C5CE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"956649\n"); + end + x = 64'h3FD001FFFF000000; + y = 64'h7FEC336E7E5B0C30; + z = 64'h43EFFFFFFFFFDFFF; + ans = 64'h7FCC36F4EA67A0AA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"958663\n"); + end + x = 64'h3FD0000000000001; + y = 64'hC000000000000000; + z = 64'h4340000000000000; + ans = 64'h433FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"960677\n"); + end + x = 64'hBFCFFC0FFFFFFFFF; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h38100000FFFFFFFC; + ans = 64'h3FEFFC0FFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"962691\n"); + end + x = 64'hBFDAF002AF16C261; + y = 64'h47EE313B7466FE84; + z = 64'hBAB00000203FFFFF; + ans = 64'hC7D96A7414C320EA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"964705\n"); + end + x = 64'h3FD0000000000001; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"966719\n"); + end + x = 64'hC3CFFFFFFFFBFFBF; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h43D0ED5944B60C56; + ans = 64'h472FFFFFFFFBFFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"968733\n"); + end + x = 64'hB796FC9D90A9E784; + y = 64'hBF000000FEFFFFFE; + z = 64'h3E1954561DD3AD12; + ans = 64'h3E1954561DD3AD12; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"970747\n"); + end + x = 64'h3FD0000000000001; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hFFD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"972761\n"); + end + x = 64'h381000000000081F; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hC3DFFFFFBFFFFFEF; + 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,"974775\n"); + end + x = 64'h3C300000FFFFF7FF; + y = 64'hC2BFFF0000000004; + z = 64'hBFCBFB075CA1326A; + ans = 64'hBFCBFC0754B131EA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"976789\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"978803\n"); + end + x = 64'h402FFFFE0FFFFFFF; + y = 64'h0010000000000001; + z = 64'hCF771A48F1DEC87F; + ans = 64'hCF771A48F1DEC87F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"980817\n"); + end + x = 64'hCC300000800003FF; + y = 64'h47A001000001FFFF; + z = 64'hC3F220870AB7024F; + ans = 64'hD3E00100800A03FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"982831\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"984845\n"); + end + x = 64'hC0F0E9718D9CDCE9; + y = 64'h3FD0000000000001; + z = 64'hC01FFFFFFFFFFEFD; + ans = 64'hC0D0EB718D9CDCEA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"986859\n"); + end + x = 64'h67900003FFFFFC00; + y = 64'hC1FFFFFFFFEFDFFF; + z = 64'hB7FFFEFFFFFFFFFF; + ans = 64'hE9A00003FFF7EBFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"988873\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"990887\n"); + end + x = 64'h47E0400007FFFFFF; + y = 64'h3FF0000000000001; + z = 64'hC1F9C1069A1BB125; + ans = 64'h47E0400008000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"992901\n"); + end + x = 64'hBFDFC0007FFFFFFF; + y = 64'h403FFFFFE00FFFFF; + z = 64'hEAA0000000020001; + ans = 64'hEAA0000000020001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"994915\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"996929\n"); + end + x = 64'hBFFFFC03FFFFFFFF; + y = 64'h4010000000000000; + z = 64'hC23FDF0000000000; + ans = 64'hC23FDF000007FF01; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"998943\n"); + end + x = 64'hBFFFFFFFFFFFFFF6; + y = 64'hC000000000803FFE; + z = 64'h43C2000000400000; + ans = 64'h43C2000000400000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1000957\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h4340000000000001; + z = 64'hBFF0000000000001; + ans = 64'h432FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1002971\n"); + end + x = 64'h37FFFEFFFFFFFFDF; + y = 64'h7FE0000000000000; + z = 64'h4BEE25EB66CB8EF7; + ans = 64'h77EFFEFFFFFFFFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1004985\n"); + end + x = 64'hBED003FFC0000000; + y = 64'hC00FFDFFFFFEFFFE; + z = 64'hBF4FFFFFFBFFFFF7; + ans = 64'hBF4F7FE7FFFFE3F8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1006999\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h7FF0000000000001; + z = 64'h4340000000000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1009013\n"); + end + x = 64'hFFDFFFF8000003FE; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h4070000801FFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1011027\n"); + end + x = 64'hFFE000000001001F; + y = 64'h434FFBFFEFFFFFFF; + z = 64'hBFFFFFFFFE007FFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1013041\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'h8010000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1015055\n"); + end + x = 64'hC080000000201000; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h41CFFDFFFFFFFFFE; + ans = 64'h41CFFDFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1017069\n"); + end + x = 64'h380FFFFFF0000010; + y = 64'h801FFFFFFFFC000E; + z = 64'hC00FFFF7FFFFFFFE; + ans = 64'hC00FFFF7FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1019083\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hBFD0000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBFC0000000000007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1021097\n"); + end + x = 64'hB7E0000000007FBF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h41EFFFFFF00003FF; + ans = 64'h41EFFFFFF00003FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1023111\n"); + end + x = 64'hB92FFFDFC0000000; + y = 64'h8020000000100006; + z = 64'hBF74CFAB3BCC97F9; + ans = 64'hBF74CFAB3BCC97F9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1025125\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hBFF0000000000000; + z = 64'h3FF0000000000001; + ans = 64'h3FE0000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1027139\n"); + end + x = 64'hDBA7D78F351ECD8C; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h3FD0001FFFFFFDFF; + ans = 64'h5BB7D78F351ECD8B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1029153\n"); + end + x = 64'hA19FFFF7FF7FFFFF; + y = 64'hBD0E000010000000; + z = 64'hC03FFFFFFBFE0000; + ans = 64'hC03FFFFFFBFE0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1031167\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'hC340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1033181\n"); + end + x = 64'h9A66ECD450DBEE9F; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h7FE0000000005FFF; + ans = 64'h7FE0000000005FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1035195\n"); + end + x = 64'hB81F7FFFFFFFDFFF; + y = 64'hC800000100000000; + z = 64'h6CB1FFFFFFBFFFFE; + ans = 64'h6CB1FFFFFFBFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1037209\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1039223\n"); + end + x = 64'hB801EB65455027DA; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hFFEFFFC000001000; + ans = 64'hFFEFFFC000001000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1041237\n"); + end + x = 64'h3F700000003FDFFF; + y = 64'hBCA0000000007FDF; + z = 64'hBF50400000007FFF; + ans = 64'hBF50400000008001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1043251\n"); + end + x = 64'h3FDFFFFFFFFFFFFF; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1045265\n"); + end + x = 64'hB7FDFBFFFFFFFFFE; + y = 64'h0000000000000001; + z = 64'h7FD000000000203F; + ans = 64'h7FD000000000203F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1047279\n"); + end + x = 64'h3FF7FFFFFFFEFFFF; + y = 64'h38700003FFFFF800; + z = 64'h4120000FFFFFFBFF; + ans = 64'h4120000FFFFFFBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1049293\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1051307\n"); + end + x = 64'hBFEFFF7FFFFBFFFF; + y = 64'h3CA0000000000001; + z = 64'hC740080000000FFE; + ans = 64'hC740080000000FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1053321\n"); + end + x = 64'h43DFFFFFFFFE0002; + y = 64'h480F9A103B845795; + z = 64'h403000007FFFFFDF; + ans = 64'h4BFF9A103B825DF6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1055335\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1057349\n"); + end + x = 64'h3FAB095E19BC680A; + y = 64'h3FE0000000000000; + z = 64'hBE74000000010000; + ans = 64'h3F9B095919BC680A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1059363\n"); + end + x = 64'h34AAE4B683C5F934; + y = 64'h47E4010000000000; + z = 64'h403FFFFFFFE00010; + ans = 64'h403FFFFFFFE00010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1061377\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h3FF0000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1063391\n"); + end + x = 64'hBFF7C5CB22453387; + y = 64'h4000000000000000; + z = 64'h7FFAF9FF7BFE0B10; + ans = 64'h7FFAF9FF7BFE0B10; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1065405\n"); + end + x = 64'hC18000000F000000; + y = 64'h488000000000FFFE; + z = 64'h41C010003FFFFFFE; + ans = 64'hCA1000000F00FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1067419\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h4010000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h3FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1069433\n"); + end + x = 64'h37F512CCFA31FCDB; + y = 64'h4340000000000000; + z = 64'h800FFFFFFE800000; + ans = 64'h3B4512CCFA31FCDB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1071447\n"); + end + x = 64'hC040010000020000; + y = 64'hBFF00000100000FE; + z = 64'h3FD5CA5E3CB16DF4; + ans = 64'h40402C94CC7C63DA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1073461\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h7FE0000000000001; + z = 64'h3FF0000000000001; + ans = 64'h7FD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1075475\n"); + end + x = 64'h43EDD3E4302B9937; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hB7E8380CF656C23A; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1077489\n"); + end + x = 64'h403000200001FFFF; + y = 64'h43EFFFFFFFFFFFFE; + z = 64'hC1EFF7DFFFFFFFFF; + ans = 64'h443000200001003F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1079503\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'h8000000000000000; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1081517\n"); + end + x = 64'hBCCFFFFFFEFFFBFF; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h402155B78FBF3A15; + ans = 64'h402155B78FBF3A15; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1083531\n"); + end + x = 64'hDBD0007FFFFF7FFF; + y = 64'h3F827A8892CBAFE7; + z = 64'h401000000000005E; + ans = 64'hDB627B1C670FB26F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1085545\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hBCA0000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1087559\n"); + end + x = 64'hB8BFFFFFFFF00040; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hC29D554AC7605657; + ans = 64'hC29D554AC7605657; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1089573\n"); + end + x = 64'h36E00000000FFF00; + y = 64'h3FE0000100000006; + z = 64'hC3FFFEFE00000000; + ans = 64'hC3FFFEFE00000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1091587\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hBFE0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hBFCFFFFFFFFFFFF6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1093601\n"); + end + x = 64'hC1D000008000003F; y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h41EFDFBFFFFFFFFF; + z = 64'h377FFFFFFFFFFF5E; + ans = 64'h41D000008000003E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1095615\n"); + end + x = 64'hBCE000000001FC00; + y = 64'h3FF80CABB0668B82; + z = 64'hB9FFFFFFFCFFFFFF; + ans = 64'hBCE80CABB0698754; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1097629\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hBFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1099643\n"); + end + x = 64'h434FFFFFFB800000; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h3B0FFFDFEFFFFFFE; + ans = 64'hC36FFFFFFB7FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1101657\n"); + end + x = 64'h3FCFBFFFFFFFDFFF; + y = 64'hF07FFE0000080000; + z = 64'h4041727FB1168149; + ans = 64'hF05FBE040007D001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1103671\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h433FFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1105685\n"); + end + x = 64'hC7E00020000007FF; + y = 64'hC340000000000001; + z = 64'h3D8081FFFFFFFFFF; + ans = 64'h4B30002000000800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1107699\n"); + end + x = 64'hBFE0D3B25C7B97A9; + y = 64'hC045BACF43664564; + z = 64'hB7F7D9E75B6702EA; + ans = 64'h4036DA510C8AE9BE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1109713\n"); + end + x = 64'h3FDFFFFFFFFFFFFE; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1111727\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hFFF0000000000001; + z = 64'h402207E547F7FB2F; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1113741\n"); + end + x = 64'hB80FFFFFFFFF001E; + y = 64'h593FFC07FFFFFFFF; + z = 64'h41C00000000007EF; + ans = 64'hD15FFC07FFFF003D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1115755\n"); + end + x = 64'h3FE0000000000000; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1117769\n"); + end + x = 64'h47EFFFF100000000; + y = 64'h0010000000000001; + z = 64'hBFBFFFBFFFFFFFBF; + ans = 64'hBFBFFFBFFFFFFFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1119783\n"); + end + x = 64'hBFE2000400000000; + y = 64'hC3C0000000FFFFFE; + z = 64'hC01FFFF7FFFFFF7F; + ans = 64'h43B200040120003E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1121797\n"); + end + x = 64'h3FE0000000000000; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1123811\n"); + end + x = 64'h3CAAA1E923207153; + y = 64'h3FD0000000000000; + z = 64'hAC0F2FA413460742; + ans = 64'h3C8AA1E923207153; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1125825\n"); + end + x = 64'h381FFFFFFFC03FFF; + y = 64'h3FCFFFFFFFFFE1FE; + z = 64'h220000000003FF00; + ans = 64'h37FFFFFFFFC021FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1127839\n"); + end + x = 64'h3FE0000000000000; + y = 64'h3FE0000000000001; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1129853\n"); + end + x = 64'hC1F000000401FFFF; + y = 64'h3FF0000000000000; + z = 64'h41D0060DA9F8C199; + ans = 64'hC1E7FCF933079F32; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1131867\n"); + end + x = 64'hB3D020000007FFFE; + y = 64'h2EBFFFFFFC000004; + z = 64'h43F0000001DFFFFF; + ans = 64'h43F0000001DFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1133881\n"); + end + x = 64'h3FE0000000000000; + y = 64'h4000000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1135895\n"); + end + x = 64'h400FFFFF7F800000; + y = 64'h4010000000000000; + z = 64'h3FE0000000400000; + ans = 64'h40307FFFBFC20000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1137909\n"); + end + x = 64'h3F0FFBE000000000; + y = 64'hBFDFFFFFDFFFFFFF; + z = 64'hC67DFFFFFFFFC000; + ans = 64'hC67DFFFFFFFFC000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1139923\n"); + end + x = 64'h3FE0000000000000; + y = 64'h4340000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h4330000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1141937\n"); + end + x = 64'h2A50000000107FFF; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hC32FFFFE01000000; + ans = 64'hC32FFFFE01000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1143951\n"); + end + x = 64'hC010003F7FFFFFFE; + y = 64'hA5EFFFFFFFF80000; + z = 64'h4520000DFFFFFFFE; + ans = 64'h4520000DFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1145965\n"); + end + x = 64'h3FE0000000000000; + y = 64'h7FF0000000000000; + z = 64'hBFF0000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1147979\n"); + end + x = 64'hBF25A31B8EC1FFCC; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hC27ECDE37A041576; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1149993\n"); + end + x = 64'hC01B7FFFFFFFFFFF; + y = 64'h3FD2A7929E3D480E; + z = 64'h3CA0000008200000; + ans = 64'hC0000801FFFCA9EB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1152007\n"); + end + x = 64'h3FE0000000000000; + y = 64'h8010000000000000; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1154021\n"); + end + x = 64'hBFFFFFFF80000040; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h3FB000008000001E; + ans = 64'h3FB000008000001E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1156035\n"); + end + x = 64'hC34FBFFFFFFFF7FE; + y = 64'h40100000001FFFBE; + z = 64'h406814B7CD412DEC; + ans = 64'hC36FC000003F7763; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1158049\n"); + end + x = 64'h3FE0000000000000; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1160063\n"); + end + x = 64'hC1F31745A108725D; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hC5D080007FFFFFFF; + ans = 64'hC5D080007FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1162077\n"); + end + x = 64'h29FFEFFFFFC00000; + y = 64'hC1F0000000000088; + z = 64'hBFBFFFFF00003FFE; + ans = 64'hBFBFFFFF00003FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1164091\n"); + end + x = 64'h3FE0000000000000; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBFE0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1166105\n"); + end + x = 64'h400FFFFFF8000010; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h2660400000800000; + ans = 64'hC01FFFFFF800000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1168119\n"); + end + x = 64'hC010000020FFFFFE; + y = 64'h5C80003FFFFFBFFF; + z = 64'hB8015F6E375E007E; + ans = 64'hDCA00040210043FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1170133\n"); + end + x = 64'h3FE0000000000000; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'hBFEFFFFFFFFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1172147\n"); + end + x = 64'h380FFE000001FFFE; + y = 64'hC010000000000001; + z = 64'hC1DF802000000000; + ans = 64'hC1DF802000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1174161\n"); + end + x = 64'h42C008FFFFFFFFFE; + y = 64'hC0200008001FFFFF; + z = 64'h43EFFFF5FFFFFFFF; + ans = 64'h43EFFFD5EDEFF6BF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1176175\n"); + end + x = 64'h3FE0000000000000; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC350000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1178189\n"); + end + x = 64'hB7E461FC806F4A9F; + y = 64'hFFE0000000000001; + z = 64'h429FFFFFFF004000; + ans = 64'h77D461FC806F4AA0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1180203\n"); + end + x = 64'hC34FFEFE00000000; + y = 64'hBC4FEFFFFFFFFFFD; + z = 64'hC020000000000087; + ans = 64'hC01FC02202FE010E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1182217\n"); + end + x = 64'h3FE0000000000000; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1184231\n"); + end + x = 64'hBFFFFFFF01FFFFFF; + y = 64'h0000000000000001; + z = 64'h41A00000100007FF; + ans = 64'h41A00000100007FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1186245\n"); + end + x = 64'h2D9000000FFFFFF0; + y = 64'hBF2FFFFDFFFFFFFF; + z = 64'h3FE001007FFFFFFE; + ans = 64'h3FE001007FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1188259\n"); + end + x = 64'h3FE0000000000001; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1190273\n"); + end + x = 64'hC1DFFFF000000FFF; + y = 64'h3CA0000000000000; + z = 64'hC3DA1DEAED50332B; + ans = 64'hC3DA1DEAED50332B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1192287\n"); + end + x = 64'hFC50FF7FFFFFFFFF; + y = 64'hB8FFC003FFFFFFFF; + z = 64'h41CFFFFFFFFE03FE; + ans = 64'h7560DD831FEFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1194301\n"); + end + x = 64'h3FE0000000000001; + y = 64'h3FD0000000000001; + z = 64'hBFF0000000000001; + ans = 64'hBFEC000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1196315\n"); + end + x = 64'hC65000000000003D; + y = 64'h3FE0000000000000; + z = 64'hC7F0008000080000; + ans = 64'hC7F0008002080000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1198329\n"); + end + x = 64'hC3E00005FFFFFFFF; + y = 64'hC3AFFFFFFFFFFC08; + z = 64'h403FFFFFFFFFFFFF; + ans = 64'h47A00005FFFFFE03; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1200343\n"); + end + x = 64'h3FE0000000000001; + y = 64'h3FF0000000000001; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1202357\n"); + end + x = 64'hC03FFFFFFFE00000; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h47F000001FFFBFFF; + ans = 64'h47F000001FFFBFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1204371\n"); + end + x = 64'hF35FFFFFFFFFFFC1; + y = 64'hC22FFFFFFFFFD000; + z = 64'h00220FFFFFFFFFFE; + ans = 64'h759FFFFFFFFFCFC1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1206385\n"); + end + x = 64'h3FE0000000000001; + y = 64'h4010000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1208399\n"); + end + x = 64'hA54C000000FFFFFF; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hC0700000002007FE; + ans = 64'hC0700000002007FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1210413\n"); + end + x = 64'hC1D000803FFFFFFE; + y = 64'h3FEFFC00000000FE; + z = 64'hBFFFFFFEFFFFEFFF; + ans = 64'hC1CFFD0060F000F2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1212427\n"); + end + x = 64'h3FE0000000000001; + y = 64'h7FE0000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h7FD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1214441\n"); + end + x = 64'h3FF0000080000FFF; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h049E4F343D92384B; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1216455\n"); + end + x = 64'h403FDFFFFE000000; + y = 64'hC011DA12116127A8; + z = 64'h7D8BFE3FAE41652F; + ans = 64'h7D8BFE3FAE41652F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1218469\n"); + end + x = 64'h3FE0000000000001; + y = 64'h8000000000000000; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1220483\n"); + end + x = 64'hAD80007FFFFFC000; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hC48000000004000E; + ans = 64'hC48000000004000E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1222497\n"); + end + x = 64'h3F1FFFFF7F000000; + y = 64'h41E007FFF0000000; + z = 64'h3FAA435B79A850E6; + ans = 64'h411007FFE3E67734; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1224511\n"); + end + x = 64'h3FE0000000000001; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1226525\n"); + end + x = 64'h43E278F2478FCA52; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h80149C3EC40D9749; + ans = 64'hC0A278F2478FCA51; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1228539\n"); + end + x = 64'hC310000040001FFF; + y = 64'hBFB03FFFFFFFFFFD; + z = 64'h41CFBFBFFFFFFFFE; + ans = 64'h42D0401020E0207C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1230553\n"); + end + x = 64'h3FE0000000000001; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1232567\n"); + end + x = 64'h39260035ABDD89AD; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h41EFDFBFFFFFFFFF; ans = 64'h41EFDFBFFFFFFFFF; rn = 1; rz = 0; @@ -94622,19 +28820,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -94650,12 +28848,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1235981\n"); + $fwrite(fp,"1234581\n"); end - xrf = 64'h3FE0000000000001; - y = 64'h8000004000000003; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFE; + x = 64'hC1A00000000017FF; + y = 64'hC800000200000010; + z = 64'hFC3F00000000FFFF; + ans = 64'hFC3F00000000FFFF; rn = 1; rz = 0; rm = 0; @@ -94669,19 +28867,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -94699,245 +28897,10 @@ initial if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); $fwrite(fp,"1236595\n"); end - xrf = 64'hC3CFFFFFFFEFFFFC; - y = 64'h3800000100000000; - zrf = 64'h0951CEBF00D210BB; - ans = 64'hBBE00000FFF7FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1237209\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'hBFF0000000000000; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h401DFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1237823\n"); - end - xrf = 64'h3CA0000007FFBFFF; - y = 64'h8003FFFFFFEFFFFF; - zrf = 64'h3FD0000000000000; - ans = 64'h3FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1238437\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'hBFF0000000000001; - zrf = 64'hC7E00FFFFFFFFBFE; - ans = 64'hC7E00FFFFFFFFBFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1239051\n"); - end - xrf = 64'hAC08231D9520F66E; - y = 64'h9D9AAF33D341D625; - zrf = 64'hBF3FFC0000000002; - ans = 64'hBF3FFC0000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1239665\n"); - end - xrf = 64'hBFD035DDA176DAD8; + x = 64'h3FE0000000000001; y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hBFEFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -94951,19 +28914,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -94979,59 +28942,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1240279\n"); + $fwrite(fp,"1238609\n"); end - xrf = 64'h3FE0000000000001; - y = 64'hC7F0000102000000; - zrf = 64'hA7202000000007FF; - ans = 64'hC7E0000102000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1240893\n"); - end - xrf = 64'h46218D1FD3FECF00; + x = 64'hBFE0FFEFFFFFFFFF; y = 64'hC000000000000001; - zrf = 64'hB8100000000006FF; - ans = 64'hC6318D1FD3FECF01; + z = 64'hC340000000002080; + ans = 64'hC34000000000207F; rn = 1; rz = 0; rm = 0; @@ -95045,19 +28961,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -95073,12 +28989,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1241507\n"); + $fwrite(fp,"1240623\n"); end - xrf = 64'h3FE0000000000001; - y = 64'h381FFFF000000FFF; - zrf = 64'hC000000000000000; - ans = 64'hC000000000000000; + x = 64'h3FCFFFF80003FFFF; + y = 64'h41EE0000007FFFFE; + z = 64'hB8E5FCA486B3001A; + ans = 64'h41CDFFF88083BFDD; rn = 1; rz = 0; rm = 0; @@ -95092,19 +29008,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -95120,247 +29036,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1242121\n"); + $fwrite(fp,"1242637\n"); end - xrf = 64'h471FFFC000000FFE; - y = 64'h37EFFF9FFFFFFFFE; - zrf = 64'h002FFFFC0000003F; - ans = 64'h3F1FFF6000C00FFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1242735\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h4010000000000000; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1243349\n"); - end - xrf = 64'h41FB90A7E035BEF8; - y = 64'hB7EFFFFFFFF80200; - zrf = 64'h3CA0000000000001; - ans = 64'h3C9FFFFFFFFFF91E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1243963\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'hC010000000000000; - zrf = 64'hC3E51EE0A2AE97C7; - ans = 64'hC3E51EE0A2AE97C7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1244577\n"); - end - xrf = 64'h3FDFFFFFBEFFFFFE; - y = 64'hF7D08BB81A011F46; - zrf = 64'hC3DF80000003FFFF; - ans = 64'hF7C08BB7F8655150; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1245191\n"); - end - xrf = 64'h49AA8FD4E56A0F22; + x = 64'h3FE0000000000001; y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; + z = 64'hBFF0000000000001; + ans = 64'hC014000000000001; rn = 1; rz = 0; rm = 0; @@ -95374,19 +29055,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -95402,12 +29083,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1245805\n"); + $fwrite(fp,"1244651\n"); end - xrf = 64'h3FE0000000000001; - y = 64'hC5FFFFFFFFFFBFFB; - zrf = 64'h801FFFFFFF7FFFDF; - ans = 64'hC5EFFFFFFFFFBFFD; + x = 64'h44C4C56F2310E46D; + y = 64'hC340000000000001; + z = 64'h6DFFFFFFFFF800FF; + ans = 64'h6DFFFFFFFFF800FF; rn = 1; rz = 0; rm = 0; @@ -95421,19 +29102,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -95449,12 +29130,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1246419\n"); + $fwrite(fp,"1246665\n"); end - xrf = 64'h7FE007FFFFFFBFFF; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hFFE0000003FFE000; - ans = 64'hFFF0000000000000; + x = 64'h390067D3F6BBE86D; + y = 64'hC7C4863B5C262EE4; + z = 64'h7FEF7FFFFFFFEFFE; + ans = 64'h7FEF7FFFFFFFEFFE; rn = 1; rz = 0; rm = 0; @@ -95468,19 +29149,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -95496,387 +29177,857 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1247033\n"); + $fwrite(fp,"1248679\n"); end - xrf = 64'h3FE0000000000001; - y = 64'hC3F4000400000000; - zrf = 64'hBFF0000000000001; - ans = 64'hC3E4000400000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1247647\n"); - end - xrf = 64'hC05FFFFFFFFFFEFB; - y = 64'h402FFFFEF8000000; - zrf = 64'hC1D1000001000000; - ans = 64'hC1D1000200FFEF80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1248261\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h4000000000000001; - ans = 64'hC33FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1248875\n"); - end - xrf = 64'hC330000000107FFE; - y = 64'h4340200000040000; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'hC68020000014A0FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1249489\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h43F1000004000000; - ans = 64'h43F0FE0004000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1250103\n"); - end - xrf = 64'h402B03E8F7B08906; - y = 64'h412996BE0A0ABEA4; - zrf = 64'hC35FFFFFFCFFFFFF; - ans = 64'hC35FFFFFFCD4CB5D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1250717\n"); - end - xrf = 64'h405FFFFFFFFFF007; - y = 64'hFFE0000000000001; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1251331\n"); - end - xrf = 64'h3FE0000000000001; - y = 64'hDF9FFFFFFFFFDFEF; - zrf = 64'hC03FFFFFFFFFE007; - ans = 64'hDF8FFFFFFFFFDFF1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1251945\n"); - end - xrf = 64'hC1C54ECCB8C1D414; + x = 64'h3FE0000000000001; y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hC3DFF7FFFFFFFDFE; + z = 64'h4340000000000000; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1250693\n"); + end + x = 64'h06C0000003FFFDFF; + y = 64'hFFF0000000000000; + z = 64'h3811FFFFFFFFFFEF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1252707\n"); + end + x = 64'hFFD000407FFFFFFF; + y = 64'h8020FFFFFFFE0000; + z = 64'h404136D99D2D1461; + ans = 64'h404246DDE5ACF460; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1254721\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h0000000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1256735\n"); + end + x = 64'hBB41FFFFFFF00000; + y = 64'h0010000000000000; + z = 64'h801F144F5AF77117; + ans = 64'h801F144F5AF77117; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1258749\n"); + end + x = 64'hC00FFFFFFFFFFFFE; + y = 64'h4531FFFFFFF7FFFE; + z = 64'h3FE001FFFFFFFFFB; + ans = 64'hC551FFFFFFF7FFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1260763\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h3CA0000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBC9FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1262777\n"); + end + x = 64'hB7E0000080000800; + y = 64'h3FD0000000000000; + z = 64'h00A40000001FFFFF; + ans = 64'hB7C0000080000800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1264791\n"); + end + x = 64'hBFD0100007FFFFFF; + y = 64'h3FD297EE8E336CA8; + z = 64'hC01000000000083E; + ans = 64'hC0104AAA1A183E9B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1266805\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h3FE0000000000001; + z = 64'h3FF0000000000001; + ans = 64'h3FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1268819\n"); + end + x = 64'h3CA040000000003F; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h47E98A1D9E231C6C; + ans = 64'h47E98A1D9E231C6C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1270833\n"); + end + x = 64'hFFDCD4A9AF8FB7F0; + y = 64'hBFA57144A8767CCA; + z = 64'h3C8FF000FFFFFFFF; + ans = 64'h7F93519C2E1A14C2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1272847\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h4000000000000000; + z = 64'hC340000000000000; + ans = 64'hC33FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1274861\n"); + end + x = 64'hC03FFF0000002000; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hB7E0DB97C33BBBF0; + ans = 64'hC05FFF0000001FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1276875\n"); + end + x = 64'h464FF83FFFFFFFFF; + y = 64'h3FF0007FFFFFFFFF; + z = 64'h3FB1000000001FFF; + ans = 64'h464FF93FC1FFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1278889\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h4340000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1280903\n"); + end + x = 64'hBFF000000000001D; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h7FED8C5A62D13B80; + ans = 64'h7FED8C5A62D13B80; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1282917\n"); + end + x = 64'hFFD0000040000400; + y = 64'h002D129AC2DAF941; + z = 64'h6DA0800000000001; + ans = 64'h6DA0800000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1284931\n"); + end + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h7FF0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -95891,19 +30042,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -95919,12 +30070,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1252559\n"); + $fwrite(fp,"1286945\n"); end - xrf = 64'h3FE0000000000001; - y = 64'hC00BFDFFFFFFFFFF; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hC005FF0000000000; + x = 64'h41DFFFFFFFFFFFDA; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hC34D972CB1581033; + ans = 64'h7FFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -95938,19 +30089,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -95966,12 +30117,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1253173\n"); + $fwrite(fp,"1288959\n"); end - xrf = 64'hBFB2BDD6B4EE5235; - y = 64'h402FFFC00000001E; - zrf = 64'hBF91FDFFFFFFFFFE; - ans = 64'hBFF305A93940E86A; + x = 64'h43E444929DC71DB3; + y = 64'h3FD0000080FFFFFF; + z = 64'h3E5FFFFF00000000; + ans = 64'h43C44493412FFBCA; rn = 1; rz = 0; rm = 0; @@ -95985,19 +30136,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -96013,12 +30164,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1253787\n"); + $fwrite(fp,"1290973\n"); end - xrf = 64'h3FE0000000000001; - y = 64'hFFF0000000000001; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'hFFF8000000000001; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; rn = 1; rz = 0; rm = 0; @@ -96032,19 +30183,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -96060,12 +30211,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1254401\n"); + $fwrite(fp,"1292987\n"); end - xrf = 64'h347AFEC51BB8EC9A; - y = 64'h43D20E68A685DF5B; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h385E76ED3C9E9BCD; + x = 64'hC1D3B0AE9C0EB661; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hFF9BFFFFFFFFC000; + ans = 64'hFF9BFFFFFFFFC000; rn = 1; rz = 0; rm = 0; @@ -96079,19 +30230,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -96107,12 +30258,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1255015\n"); + $fwrite(fp,"1295001\n"); end - xrf = 64'h3FE0000000000001; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hA41003FF80000000; - ans = 64'hFFFFFFFFFFFFFFFF; + x = 64'h42AEFFFFFFFFFBFE; + y = 64'h4040080000040000; + z = 64'hC0000000000087FE; + ans = 64'h42FF0F800007BBDC; rn = 1; rz = 0; rm = 0; @@ -96126,19 +30277,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -96154,12 +30305,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1255629\n"); + $fwrite(fp,"1297015\n"); end - xrf = 64'h0011000800000000; - y = 64'h4017797633517F39; - zrf = 64'hBF5F0000000003FF; - ans = 64'hBF5F0000000003FF; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; rn = 1; rz = 0; rm = 0; @@ -96173,19 +30324,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -96201,12 +30352,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1256243\n"); + $fwrite(fp,"1299029\n"); end - xrf = 64'h408FF7FFFF7FFFFF; - y = 64'h0000000000000000; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h401FFFFFFFFFFFFE; + x = 64'h4030080004000000; + y = 64'hBFD0000000000001; + z = 64'h74A074EB9DE02CCE; + ans = 64'h74A074EB9DE02CCE; rn = 1; rz = 0; rm = 0; @@ -96220,19 +30371,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -96248,12 +30399,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1256857\n"); + $fwrite(fp,"1301043\n"); end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h4030800000FFFFFF; - zrf = 64'h44200FFFFFFFFF7F; - ans = 64'h44200FFFFFFFFF7F; + x = 64'h42401FFFFFFFFBFF; + y = 64'hBFEFFFFFFFFFC03F; + z = 64'hBE500200000003FE; + ans = 64'hC2401FFFFFFFDBDF; rn = 1; rz = 0; rm = 0; @@ -96267,19 +30418,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -96295,12 +30446,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1257471\n"); + $fwrite(fp,"1303057\n"); end - xrf = 64'hB7EC1C59B4C2E8E1; - y = 64'h0000000000000001; - zrf = 64'h00100000007FFE00; - ans = 64'h00100000007FFE00; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -96314,19 +30465,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -96342,12 +30493,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1258085\n"); + $fwrite(fp,"1305071\n"); end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hBE1FFFFFFFC0007E; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFE0000000FFFFFF; + x = 64'h47FFFFFFDFEFFFFF; + y = 64'hBFF0000000000001; + z = 64'hC1EFF7FFFFFFFFFD; + ans = 64'hC7FFFFFFDFF00001; rn = 1; rz = 0; rm = 0; @@ -96361,19 +30512,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -96389,199 +30540,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1258699\n"); + $fwrite(fp,"1307085\n"); end - xrf = 64'h403000000001FFFB; - y = 64'hBFD340F99E89EBF4; - zrf = 64'hCDCBCAB1F16B5FD2; - ans = 64'hCDCBCAB1F16B5FD2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1259313\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h0010000000000000; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h3FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1259927\n"); - end - xrf = 64'hBFBFFFFFC3FFFFFE; - y = 64'hBFB00800000FFFFE; - zrf = 64'h0000000000000000; - ans = 64'h3F8007FFE200FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1260541\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h0010000000000001; - zrf = 64'hC34080FFFFFFFFFF; - ans = 64'hC34080FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1261155\n"); - end - xrf = 64'hD03FF10000000000; - y = 64'h7FEA066340366A48; - zrf = 64'h3FBFFFFFFFF0000E; + x = 64'hFFDB5F9FBB1A65C5; + y = 64'h4BBFDFFFFFFFFFFF; + z = 64'hBE800000000003FF; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -96596,19 +30559,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -96624,12 +30587,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1261769\n"); + $fwrite(fp,"1309099\n"); end - xrf = 64'h9C9FFF8000000100; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h4010000000000000; - ans = 64'h4010000000000000; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hC00FFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -96643,19 +30606,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -96671,12 +30634,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1262383\n"); + $fwrite(fp,"1311113\n"); end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hC030000000101FFF; - zrf = 64'h4020400000010000; - ans = 64'hC01F8000003E7FFA; + x = 64'hABBFFFF7FFFFFF7E; + y = 64'hC010000000000001; + z = 64'hFFE5AD5572946888; + ans = 64'hFFE5AD5572946888; rn = 1; rz = 0; rm = 0; @@ -96690,19 +30653,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -96718,12 +30681,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1262997\n"); + $fwrite(fp,"1313127\n"); end - xrf = 64'hC1F00007FFFFFFC0; - y = 64'h3CA0000000000000; - zrf = 64'h3DD003FFFFFDFFFE; - ans = 64'hBE9FFF0FBFFFFFA0; + x = 64'hC2200000000100FE; + y = 64'hC1CE000000007FFE; + z = 64'h4C20020000000008; + ans = 64'h4C20020000000008; rn = 1; rz = 0; rm = 0; @@ -96737,19 +30700,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -96765,998 +30728,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1263611\n"); + $fwrite(fp,"1315141\n"); end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hCEFFFFC00007FFFF; - zrf = 64'hBFD0000000000000; - ans = 64'hCEFFFFC00007FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1264225\n"); - end - xrf = 64'h205E03FFFFFFFFFF; - y = 64'h7FDB0898E3B7A8A5; - zrf = 64'h402750419179B0FB; - ans = 64'h60495B706898A50F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1264839\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE0000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1265453\n"); - end - xrf = 64'hC000689C3D2EB143; - y = 64'h3C69E300BC404381; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1266067\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h3FD0000000000000; - zrf = 64'h40740CF10515C336; - ans = 64'h407410F10515C336; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1266681\n"); - end - xrf = 64'hC1C0FFFFFFFFFFC0; - y = 64'h43E00FFFFFFFFFF8; - zrf = 64'hBFFFFFFFE0000007; - ans = 64'hC5B110FFFFFFFFB7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1267295\n"); - end - xrf = 64'hC280000FFDFFFFFF; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h4000000000000001; - ans = 64'hC270000FFDFFDFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1267909\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h5D78B059EC0D3BA4; - zrf = 64'h7FD0000000009FFE; - ans = 64'h7FD0000000009FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1268523\n"); - end - xrf = 64'hC3E1495E8BBE1289; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h4FB000047FFFFFFE; - ans = 64'h4FB000047FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1269137\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h480000000005FFFF; - zrf = 64'hBCA0000000000001; - ans = 64'h480000000005FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1269751\n"); - end - xrf = 64'hB7EFFFFFFC000200; - y = 64'h705041FFFFFFFFFF; - zrf = 64'h3F23B0A5836E544A; - ans = 64'hE85041FFFDF7C103; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1270365\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h3FD0000000000001; - ans = 64'h3FF3FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1270979\n"); - end - xrf = 64'h4284920C713155BB; - y = 64'h4002F779DFFEC571; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1271593\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'hC6522AF710929EDB; - ans = 64'hC6522AF710929EDB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1272207\n"); - end - xrf = 64'hC077FFFFFFFFFFF7; - y = 64'h3FFE0000000FFFFE; - zrf = 64'hC1EFFFFFFFFF0001; - ans = 64'hC1F000002CFF8001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1272821\n"); - end - xrf = 64'hFFDFFFFFFFF8003F; - y = 64'h3FF0000000000001; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'hFFDFFFFFFFF80041; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1273435\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hBC0FFFC0FFFFFFFF; - zrf = 64'h4004000000000001; - ans = 64'h4004000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1274049\n"); - end - xrf = 64'h8A9FFFFEBFFFFFFE; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h37EFFC0000000800; - ans = 64'h37EFFC0000000800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1274663\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h43C800000FFFFFFE; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h43C800000FFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1275277\n"); - end - xrf = 64'hBFEFFFFFFFFFFE07; - y = 64'h401658E0BF3B7A12; - zrf = 64'hBD5000004003FFFE; - ans = 64'hC01658E0BF3B79B1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1275891\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h4000000000000001; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h4000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1276505\n"); - end - xrf = 64'hBF9DFE4AA0DF2EF9; - y = 64'h3FB01000000001FF; - zrf = 64'hC34FFFFFFFFFFFFE; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h3FF0000000000001; ans = 64'hC34FFFFFFFFFFFFE; rn = 1; rz = 0; @@ -97771,19 +30747,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -97799,12 +30775,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1277119\n"); + $fwrite(fp,"1317155\n"); end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hBFF00020001FFFFF; - ans = 64'h4007FFEFFFEFFFFF; + x = 64'hBD7FFFFFC0000100; + y = 64'hFFE0000000000000; + z = 64'hBF1EBA24E2EE0662; + ans = 64'h7D6FFFFFC0000100; rn = 1; rz = 0; rm = 0; @@ -97818,19 +30794,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -97846,12 +30822,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1277733\n"); + $fwrite(fp,"1319169\n"); end - xrf = 64'hBEFFFFFB7FFFFFFF; - y = 64'h3FF2A08A53EA01BD; - zrf = 64'hDB700007FFFFFDFE; - ans = 64'hDB700007FFFFFDFE; + x = 64'h551DF7FFFFFFFFFF; + y = 64'hBAC0000100800000; + z = 64'hC03FDFFFFFFFBFFE; + ans = 64'hCFEDF801E06FBFFF; rn = 1; rz = 0; rm = 0; @@ -97865,19 +30841,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -97893,12 +30869,576 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1278347\n"); + $fwrite(fp,"1321183\n"); end - xrf = 64'hC340000001FFFBFF; + x = 64'h3FEFFFFFFFFFFFFF; + y = 64'hFFF0000000000001; + z = 64'hC340000000000000; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1323197\n"); + end + x = 64'hBFBFFCFFFFFFFFFF; + y = 64'h0000000000000000; + z = 64'hC03FF80000080000; + ans = 64'hC03FF80000080000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1325211\n"); + end + x = 64'h41C69C7D72FE8076; + y = 64'hB800001F7FFFFFFF; + z = 64'hBE37136C430968EF; + ans = 64'hBE37136C430968EF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1327225\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h0010000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1329239\n"); + end + x = 64'h38100000008001FF; + y = 64'h3CA0000000000000; + z = 64'h801FE000003FFFFF; + ans = 64'h34C00000008001FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1331253\n"); + end + x = 64'hC03000000103FFFF; + y = 64'h43CFFFFFFBF00000; + z = 64'hC00FFFC000000010; + ans = 64'hC40FFFFFFDF7FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1333267\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h3FD0000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3FD0000000000004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1335281\n"); + end + x = 64'hBFE00FDFFFFFFFFF; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h3BCFFFFC0000000E; + ans = 64'hBFD00FDFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1337295\n"); + end + x = 64'h439FFFFFFF0001FF; + y = 64'hC04FFFFFEF7FFFFF; + z = 64'hC1D0000000300000; + ans = 64'hC3FFFFFFEE8401FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1339309\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h3FF0000000000000; + z = 64'hBFF0000000000001; + ans = 64'hBCC0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1341323\n"); + end + x = 64'h7FDFFFBFFFFFF7FF; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hBBDFFFFFF8000007; + ans = 64'h7FEFFFBFFFFFF7FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1343337\n"); + end + x = 64'hC1C985AAEB8A0850; + y = 64'h43C80000000007FF; + z = 64'hD7A0000001FFFFDF; + ans = 64'hD7A0000001FFFFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1345351\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; y = 64'h4010000000000000; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'hC360000001FFFBFF; + z = 64'h4340000000000000; + ans = 64'h4340000000000002; rn = 1; rz = 0; rm = 0; @@ -97912,19 +31452,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -97940,12 +31480,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1278961\n"); + $fwrite(fp,"1347365\n"); end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h37F0F632AC29B9C3; - zrf = 64'h3FF0007FFFFFF7FF; - ans = 64'h3FF0007FFFFFF7FF; + x = 64'hC3D401674FDC0C53; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h3817CDE6162EB580; + ans = 64'hC40401674FDC0C52; rn = 1; rz = 0; rm = 0; @@ -97959,19 +31499,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -97987,12 +31527,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1279575\n"); + $fwrite(fp,"1349379\n"); end - xrf = 64'h3FEB152BF5A33E69; - y = 64'h4010000000000001; - zrf = 64'h3800400000004000; - ans = 64'h400B152BF5A33E6B; + x = 64'h405CA61FE7E505E2; + y = 64'h3F30EFBB517C2470; + z = 64'h8B60000004000003; + ans = 64'h3F9E5360CBF9236A; rn = 1; rz = 0; rm = 0; @@ -98006,19 +31546,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -98034,12 +31574,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1280189\n"); + $fwrite(fp,"1351393\n"); end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h43C02D27FC4AB999; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h43C02D27FC4AB998; + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -98053,19 +31593,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -98081,12 +31621,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1280803\n"); + $fwrite(fp,"1353407\n"); end - xrf = 64'h411FFFFFFF80FFFF; - y = 64'hC1FFFFFFFFF7F7FF; - zrf = 64'h373C000400000000; - ans = 64'hC32FFFFFFF78F7FE; + x = 64'h033DB2D386A2A816; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h46B0010000FFFFFE; + ans = 64'h46B0010000FFFFFE; rn = 1; rz = 0; rm = 0; @@ -98100,19 +31640,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -98128,11 +31668,2032 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1281417\n"); + $fwrite(fp,"1355421\n"); end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h4340000000000000; - zrf = 64'h001FFFFFFFFFFFFE; + x = 64'h002FFFFFFFDFEFFE; + y = 64'h270010000FFFFFFF; + z = 64'hBFFFFFFFE000003F; + ans = 64'hBFFFFFFFE000003F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1357435\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1359449\n"); + end + x = 64'hC0A48931C5AB7A58; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h3FC00007FFFFFDFE; + ans = 64'h3FC00007FFFFFDFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1361463\n"); + end + x = 64'hA0BFFFFFFDFFFFF0; + y = 64'h46AD4FFFD6676AA5; + z = 64'h977FFFFFFF800FFF; + ans = 64'hA77D4FFFD4926A99; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1363477\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1365491\n"); + end + x = 64'h434FE000FFFFFFFF; + y = 64'hBCA0000000000001; + z = 64'h3FA600A985274F0B; + ans = 64'hBFFF2FFBB3D6C589; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1367505\n"); + end + x = 64'h43C567CDE92A1DFD; + y = 64'hB8000203FFFFFFFE; + z = 64'h3EE00000007FDFFF; + ans = 64'h3EE00000007FDFF4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1369519\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1371533\n"); + end + x = 64'h40300100000001FF; + y = 64'hBFE0000000000001; + z = 64'hB7EDF5A886053A5C; + ans = 64'hC020010000000200; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1373547\n"); + end + x = 64'h400000400003FFFF; + y = 64'h3FDFF01FFFFFFFFF; + z = 64'h001C0000000001FE; + ans = 64'h3FEFF09FC087FC05; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1375561\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1377575\n"); + end + x = 64'h97A7FFFFFFBFFFFF; + y = 64'hC000000000000001; + z = 64'h8000200000000020; + ans = 64'h17B7FFFFFFC00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1379589\n"); + end + x = 64'hBCAFFFFFEFFF0000; + y = 64'hBD20080000FFFFFF; + z = 64'hC3E000000FFFFFF8; + ans = 64'hC3E000000FFFFFF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1381603\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hC01FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1383617\n"); + end + x = 64'hC34000000000040E; + y = 64'hC340000000000000; + z = 64'hC04FC01FFFFFFFFE; + ans = 64'h469000000000040E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1385631\n"); + end + x = 64'h002D10706BA03B55; + y = 64'h3FC00002FFFFFFFE; + z = 64'h483569E1B1DB2A67; + ans = 64'h483569E1B1DB2A67; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1387645\n"); + end + x = 64'h3FEFFFFFFFFFFFFE; + y = 64'hFFE0000000000001; + z = 64'hBFF0000000000001; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1389659\n"); + end + x = 64'hC2BFFFFFFFBFFBFF; + y = 64'hFFF0000000000000; + z = 64'h4023FFFFFFFFFFFA; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1391673\n"); + end + x = 64'h41F000007FFFFBFE; + y = 64'h3FEF177822A30420; + z = 64'hC0A0001040000000; + ans = 64'h41EF17781B5DB96B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1393687\n"); + end + x = 64'h3FF0000000000000; + y = 64'h0000000000000001; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1395701\n"); + end + x = 64'hC7F00000007FFFE0; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hBFDFFFFFFEFFFBFF; + ans = 64'hBFDFFFFFFEFFFBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1397715\n"); + end + x = 64'h3FF0000000005000; + y = 64'h00100001F0000000; + z = 64'hC3F5CFC170570406; + ans = 64'hC3F5CFC170570406; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1399729\n"); + end + x = 64'h3FF0000000000000; + y = 64'h3CA0000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1401743\n"); + end + x = 64'h42C2000001FFFFFF; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h3FDFF80000002000; + ans = 64'h3FE0440000081000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1403757\n"); + end + x = 64'h4010000007F7FFFE; + y = 64'h8029B242064AB31E; + z = 64'h3FBFFFFF001FFFFE; + ans = 64'h3FBFFFFF001FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1405771\n"); + end + x = 64'h3FF0000000000000; + y = 64'h3FE0000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h3FDFFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1407785\n"); + end + x = 64'h47BFFFFFFFEFFE00; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'hEA1000200000003E; + ans = 64'hEA1000200000003E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1409799\n"); + end + x = 64'h3FBFFFFFE01FFFFE; + y = 64'h60DFFFEFFFBFFFFF; + z = 64'hBF0FFFFFF7FFF7FE; + ans = 64'h60AFFFEFDFE00FED; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1411813\n"); + end + x = 64'h3FF0000000000000; + y = 64'h4000000000000000; + z = 64'h3FF0000000000001; + ans = 64'h4008000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1413827\n"); + end + x = 64'hC02CE0C00CAC853F; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hC36FFFC0000FFFFE; + ans = 64'hC36FFFC000100005; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1415841\n"); + end + x = 64'h41DFFFFFFFFFFF1F; + y = 64'hCEE1FFFFFFFFFBFE; + z = 64'hC9CFFFFFFFFFFFFE; + ans = 64'hD0D1FFFFFFFFFB7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1417855\n"); + end + x = 64'h3FF0000000000000; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'hC33FFFFFFFFFFFF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1419869\n"); + end + x = 64'h3FCFFFFFFFE00800; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h4F800003FFFDFFFF; + ans = 64'h4F800003FFFDFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1421883\n"); + end + x = 64'hBCAFFFFFFFFFEFFC; + y = 64'h216FFFF00000007F; + z = 64'h48070BD481024D09; + ans = 64'h48070BD481024D09; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1423897\n"); + end + x = 64'h3FF0000000000000; + y = 64'h7FEFFFFFFFFFFFFE; + 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,"1425911\n"); + end + x = 64'hC3D0000000FFFFFB; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h400000000040000F; + 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,"1427925\n"); + end + x = 64'h41DFEF145604B84F; + y = 64'h3DAC1CF43ACD55BE; + z = 64'hB365D3A97C96806B; + ans = 64'h3F9C0E16B6B8B351; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1429939\n"); + end + x = 64'h3FF0000000000000; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1431953\n"); + end + x = 64'h3FF0000000010006; + y = 64'h8010000000000001; + z = 64'h801F7FFFFFFFFFFF; + ans = 64'h8027C00000008003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1433967\n"); + end + x = 64'hFFFBA44D53A606C1; + y = 64'h43E0001000000100; + z = 64'hC0300007FFFDFFFE; + ans = 64'hFFFBA44D53A606C1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1435981\n"); + end + x = 64'h3FF0000000000000; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1437995\n"); + end + x = 64'hC3FFFFFFF003FFFE; + y = 64'hBFD0000000000001; + z = 64'hD5C00008000007FF; + ans = 64'hD5C00008000007FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1440009\n"); + end + x = 64'h63FD9936CEA127DA; + y = 64'hC6D0000009FFFFFF; + z = 64'hBFE0007FFFFFFF00; + ans = 64'hEADD9936E120EA19; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1442023\n"); + end + x = 64'h3FF0000000000000; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h4340000000000000; ans = 64'h433FFFFFFFFFFFFF; rn = 1; rz = 0; @@ -98147,19 +33708,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -98175,1939 +33736,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1282031\n"); + $fwrite(fp,"1444037\n"); end - xrf = 64'hBF900000003FFFFE; - y = 64'h3FA081FFFFFFFFFF; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1282645\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h4340000000000001; - zrf = 64'hC1EFC0003FFFFFFF; - ans = 64'h433FFFFF01FFFE01; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1283259\n"); - end - xrf = 64'h3FD0020020000000; - y = 64'h4B50000010000007; - zrf = 64'h41E00FFFFFFFBFFF; - ans = 64'h4B30020030020027; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1283873\n"); - end - xrf = 64'hB7EFFFFBFFFFFFF7; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1284487\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hC133A27B1EA10710; - zrf = 64'h47E1000200000000; - ans = 64'h47E1000200000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1285101\n"); - end - xrf = 64'h40500008001FFFFF; - y = 64'h7FE0000000000000; - zrf = 64'h3DC0007BFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1285715\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hC20EBA2FF0240962; - zrf = 64'h8000000000000000; - ans = 64'hC20EBA2FF0240961; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1286329\n"); - end - xrf = 64'h41F0000000FFFF80; - y = 64'hBFB00000800003FE; - zrf = 64'h406FFF80000007FF; - ans = 64'hC1AFFFFF0208070C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1286943\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h0010000000000000; - ans = 64'h7FEFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1287557\n"); - end - xrf = 64'h40200000007FFEFE; - y = 64'hBF90000000FFDFFF; - zrf = 64'hC010000000000001; - ans = 64'hC0108000000BFEF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1288171\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h7FF0000000000000; - zrf = 64'h41E8000000000080; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1288785\n"); - end - xrf = 64'h4340000000010001; - y = 64'h380FFFFFFFDEFFFF; - zrf = 64'h301000000000207F; - ans = 64'h3B5FFFFFFFE10001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1289399\n"); - end - xrf = 64'h40AFFFBFFFFE0000; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h3FD0000000000001; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1290013\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hBCA7FFFFFFFFFEFF; - zrf = 64'h070FE00000000800; - ans = 64'hBCA7FFFFFFFFFEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1290627\n"); - end - xrf = 64'hF5FFFFFFFDDFFFFF; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h5D8FFFFFFDFFFFFD; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1291241\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hBFEC736A2BE2AD7C; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1291855\n"); - end - xrf = 64'hBFE80000001FFFFE; - y = 64'h4014000000200000; - zrf = 64'h41CE092D9BE1AC67; - ans = 64'h41CE092D9A01AC67; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1292469\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h0000000000000001; - ans = 64'h800FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1293083\n"); - end - xrf = 64'hBF30004000000008; - y = 64'h41CFFBFFEFFFFFFE; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC10FFC9FDFFFC00E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1293697\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'hA250000000000802; - ans = 64'hA250000000000802; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1294311\n"); - end - xrf = 64'h5650000007FF7FFF; - y = 64'hBF0FFFFFFDBFFFFE; - zrf = 64'h7FE0000000FFFEFF; - ans = 64'h7FE0000000FFFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1294925\n"); - end - xrf = 64'hBE2000000000006F; - y = 64'h8010000000000001; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1295539\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h384007FFFE000000; - zrf = 64'hBF8801FFFFFFFFFE; - ans = 64'hBF8801FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1296153\n"); - end - xrf = 64'h3C48C93EA9A07ED5; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'hBFF0000FFFFFFFEF; - ans = 64'hBFF0000FFFFFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1296767\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h4E30000200FFFFFF; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1297381\n"); - end - xrf = 64'hB7FBD8C8068C6E0C; - y = 64'h3EC0CCF1D11F2D71; - zrf = 64'h37E1FFFFFFFEFFFE; - ans = 64'h37E1FFF8B0A0C977; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1297995\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hBCA0000000000000; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1298609\n"); - end - xrf = 64'h41A01BFFFFFFFFFF; - y = 64'hB14000000100001E; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hBFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1299223\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h8A5100000007FFFE; - ans = 64'hBCAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1299837\n"); - end - xrf = 64'hC02CF7239E657AB3; - y = 64'hC02133A02874B10A; - zrf = 64'hC340000020000003; - ans = 64'hC34000001FFFFFC5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1300451\n"); - end - xrf = 64'hC01FFEFFE0000000; - y = 64'hBFD0000000000000; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h3FFFFEFFE0000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1301065\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hC0000000001FDFFF; - zrf = 64'h3FB0200000000004; - ans = 64'hBFFEFE00003FBFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1301679\n"); - end - xrf = 64'hC3F000000013FFFF; - y = 64'hBFD0000000000001; - zrf = 64'hFFFFEFFFFFFFE000; - ans = 64'hFFFFEFFFFFFFE000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1302293\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h97800000000007FE; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1302907\n"); - end - xrf = 64'hC8002250949885EE; - y = 64'hBDD0000000400002; - zrf = 64'h38B08007FFFFFFFE; - ans = 64'h45E0225094D90F32; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1303521\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1304135\n"); - end - xrf = 64'h7FF020FFFFFFFFFE; - y = 64'h4B1007FFFFFFFDFF; - zrf = 64'hBFF0000000000000; - ans = 64'h7FF820FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1304749\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hBFE0000000000001; - zrf = 64'h19CD37F4AB573BAD; - ans = 64'hBFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1305363\n"); - end - xrf = 64'h3FD7F4759BBC33AC; - y = 64'h0001FFF7FFFFFFFE; - zrf = 64'hC47A74EAEF324D40; - ans = 64'hC47A74EAEF324D40; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1305977\n"); - end - xrf = 64'hC4300000000801FF; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h0010000000000000; - ans = 64'h44300000000801FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1306591\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hC3E9F02373D523CF; - zrf = 64'h434FFFFFFFDFFF7E; - ans = 64'hC3E9E82373D52BCE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1307205\n"); - end - xrf = 64'h3FB8102FC1161058; + x = 64'h4063FFDFFFFFFFFF; y = 64'hBFF0000000000000; - zrf = 64'h471FFFFFFFFFBFF7; - ans = 64'h471FFFFFFFFFBFF7; + z = 64'hC78AE48A8E9C7B11; + ans = 64'hC78AE48A8E9C7B11; rn = 1; rz = 0; rm = 0; @@ -100121,19 +33755,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -100149,12 +33783,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1307819\n"); + $fwrite(fp,"1446051\n"); end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hC0A9793A9BECD88F; - zrf = 64'h4340000000000000; - ans = 64'h433FFFFFFFFFF343; + x = 64'hBD37F0CA9648274B; + y = 64'h400FFFFFFF0000FF; + z = 64'h802000007FFBFFFF; + ans = 64'hBD57F0CA9588A1B5; rn = 1; rz = 0; rm = 0; @@ -100168,19 +33802,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -100196,1327 +33830,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1308433\n"); + $fwrite(fp,"1448065\n"); end - xrf = 64'hC7FFDFFFFFBFFFFF; - y = 64'hC390000003FFFFFD; - zrf = 64'hBF4FFFFFF000FFFE; - ans = 64'h4B9FE00007B7FFF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1309047\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1309661\n"); - end - xrf = 64'hB6C7632F24A774E2; - y = 64'hBFC000200000001F; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1310275\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hC000000000000000; - zrf = 64'hC177FCA22F433E8D; - ans = 64'hC177FCA24F433E8D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1310889\n"); - end - xrf = 64'hC1CFFFFFFFFFF5FF; - y = 64'hBFB0000000FFFDFE; - zrf = 64'h3FAFFFFE00000040; - ans = 64'h41900000013FF8F9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1311503\n"); - end - xrf = 64'h45CFE0000000007F; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h0000000000000001; - ans = 64'hC5EFE0000000007E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1312117\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h801A837F2AE19C47; - zrf = 64'h4020800000000007; - ans = 64'h4020800000000007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1312731\n"); - end - xrf = 64'hC7FFFFC000000001; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'hC3C0F052C00D8DA7; - ans = 64'h481FFFBFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1313345\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hC1E16294F17A2FC0; - zrf = 64'h4010000000000001; - ans = 64'hC1E16294F0FA2FBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1313959\n"); - end - xrf = 64'hBCBC000000000000; - y = 64'h4100000001040000; - zrf = 64'h401000FFFFFFE000; - ans = 64'h401000FFFFFF0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1314573\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hC010000000000001; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1315187\n"); - end - xrf = 64'h3F70000000201FFF; - y = 64'h363008000000FFFF; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1315801\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hC3471DB14B06DAD6; - ans = 64'hC3471DB14B06DADA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1316415\n"); - end - xrf = 64'hC1FF3AD94ADF7008; - y = 64'h3FCF000000000002; - zrf = 64'hC071000000000200; - ans = 64'hC1DE4102C488748A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1317029\n"); - end - xrf = 64'hEEBE30496FC34DC3; - y = 64'hC340000000000000; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1317643\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hBFDFF8000003FFFF; - zrf = 64'h9DBFFFFE003FFFFF; - ans = 64'hBFDFF8000003FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1318257\n"); - end - xrf = 64'h401C285C5FADB760; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hBA5FFFFE0000003F; - ans = 64'hC37C285C5FADB75F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1318871\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h3B70000400FFFFFF; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h400FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1319485\n"); - end - xrf = 64'h40100FFFFFFFFFFE; - y = 64'h14B0001FFFFFFFFF; - zrf = 64'hC1C02FFFFFFFFFFF; - ans = 64'hC1C02FFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1320099\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hFFE0000000000000; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hFFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1320713\n"); - end - xrf = 64'hAEF00000047FFFFF; - y = 64'hC017FFFFFFFFFFFC; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hBCAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1321327\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hBFC0100000400000; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1321941\n"); - end - xrf = 64'hC1E0000000400100; - y = 64'h355FFFF80000007F; - zrf = 64'h41D359926AF53F43; - ans = 64'h41D359926AF53F43; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1322555\n"); - end - xrf = 64'h480000000001FF7E; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1323169\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hE06FFFFFFF00001E; - zrf = 64'h3E2EE32E2DA9DA61; - ans = 64'hE06FFFFFFF00001D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1323783\n"); - end - xrf = 64'hBE843F1957410156; - y = 64'hFFF0000000000001; - zrf = 64'h0000020000001000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1324397\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'h43FFFFFFC0000400; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h43FFFFFFC00003FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1325011\n"); - end - xrf = 64'h3FBFFFFF000003FE; - y = 64'hBFF007FFFFC00000; - zrf = 64'h3FA0000000001008; - ans = 64'hBFB80FFEFEFFFC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1325625\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFF; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'hC00FFFFFFFFFFFFE; + x = 64'h3FF0000000000000; + y = 64'hC000000000000001; + z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -101531,19 +33849,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -101559,12 +33877,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1326239\n"); + $fwrite(fp,"1450079\n"); end - xrf = 64'h41C4A5EB10FE5857; - y = 64'h402FFFFFFE0001FF; - zrf = 64'hBCA0000000000000; - ans = 64'h4204A5EB0FB3FAF0; + x = 64'h400FFFFFFFFFFFFE; + y = 64'hC010000000000000; + z = 64'hC80F001FFFFFFFFF; + ans = 64'hC80F001FFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -101578,19 +33896,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -101606,12 +33924,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1326853\n"); + $fwrite(fp,"1452093\n"); end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h0000000000000001; - zrf = 64'h28D30F43996477D5; - ans = 64'h28D30F43996477D5; + x = 64'hBB70000040000000; + y = 64'hAB3FFFFFFFFFFFF0; + z = 64'h3FCFBFFEFFFFFFFF; + ans = 64'h3FCFBFFEFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -101625,19 +33943,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -101653,481 +33971,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1327467\n"); + $fwrite(fp,"1454107\n"); end - xrf = 64'h6DB0000004000001; - y = 64'hBFCE75F930ACC3A2; - zrf = 64'hC1EFFFFFE1FFFFFF; - ans = 64'hED8E75F9384A41F0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1328081\n"); - end - xrf = 64'hBFEF7FFFFFFBFFFF; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1328695\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h4020000000800008; - zrf = 64'hC80FF807FFFFFFFF; - ans = 64'hC80FF807FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1329309\n"); - end - xrf = 64'h433FFFFFF0000008; - y = 64'h0010000000000000; - zrf = 64'h47EFF00000000100; - ans = 64'h47EFF00000000100; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1329923\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h43F003FFFFE00000; - zrf = 64'h3FF0000000000000; - ans = 64'h43F003FFFFDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1330537\n"); - end - xrf = 64'hC0200000000200FF; - y = 64'hBFC000000007FFE0; - zrf = 64'hFD10207FFFFFFFFE; - ans = 64'hFD10207FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1331151\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hC000000000000000; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1331765\n"); - end - xrf = 64'hAEA2D2DFA3D2A4D3; - y = 64'hC1700080000007FF; - zrf = 64'h8010000000000001; - ans = 64'h3022D3763ACFCCD0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1332379\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h3CA0000000000000; - zrf = 64'h4A83FFFFBFFFFFFE; - ans = 64'h4A83FFFFBFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1332993\n"); - end - xrf = 64'hB5A541B1DC1A499A; - y = 64'h3DDFFFF000000080; - zrf = 64'h8010D30DDE0007DB; - ans = 64'hB39541A73B415BE2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1333607\n"); - end - xrf = 64'h3D0FFFFFFFFFF010; - y = 64'h3CA0000000000001; - zrf = 64'hC340000000000001; + x = 64'h3FF0000000000000; + y = 64'hC340000000000001; + z = 64'hBCAFFFFFFFFFFFFF; ans = 64'hC340000000000001; rn = 1; rz = 0; @@ -102142,19 +33990,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -102170,12 +34018,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1334221\n"); + $fwrite(fp,"1456121\n"); end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h3FC004000000003E; - zrf = 64'h47F742E3F90D4517; - ans = 64'h47F742E3F90D4517; + x = 64'hBFBFFFF0000FFFFF; + y = 64'hFFE0000000000000; + z = 64'hB80FF003FFFFFFFF; + ans = 64'h7FAFFFF0000FFFFF; rn = 1; rz = 0; rm = 0; @@ -102189,19 +34037,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -102217,12 +34065,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1334835\n"); + $fwrite(fp,"1458135\n"); end - xrf = 64'h8FBFF78000000000; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'hC1F8000000000400; - ans = 64'hC1F8000000000400; + x = 64'h40278F9EB19E2877; + y = 64'h800C3F9986C3ABCE; + z = 64'h380FFFFFF8080000; + ans = 64'h380FFFFFF8080000; rn = 1; rz = 0; rm = 0; @@ -102236,19 +34084,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -102264,12 +34112,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1335449\n"); + $fwrite(fp,"1460149\n"); end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h43FFFFFFF801FFFE; - zrf = 64'h3FE0000000000001; - ans = 64'h43FFFFFFF801FFFC; + x = 64'h3FF0000000000000; + y = 64'hFFF0000000000001; + z = 64'h3FF0000000000001; + ans = 64'hFFF8000000000001; rn = 1; rz = 0; rm = 0; @@ -102283,19 +34131,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -102311,2502 +34159,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1336063\n"); + $fwrite(fp,"1462163\n"); end - xrf = 64'h4063FFFFFFFF0000; - y = 64'hC39FFFFFF8000000; - zrf = 64'h3FDDFFFFEFFFFFFF; - ans = 64'hC413FFFFFAFF0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1336677\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h3FD0000000000001; - zrf = 64'hBFF0000000000001; - ans = 64'hBFE8000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1337291\n"); - end - xrf = 64'h484FFFFFFEFFDFFE; - y = 64'h43DFFFFFFFFFFFFA; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h4C3FFFFFFEFFDFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1337905\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'hBFFAADFFB24BA446; - ans = 64'hBFF2ADFFB24BA447; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1338519\n"); - end - xrf = 64'h3CDFFFFFFFFFFE1F; - y = 64'h406000FFFFC00000; - zrf = 64'h39D8B0F072271B05; - ans = 64'h3D5000FFFFBFFF10; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1339133\n"); - end - xrf = 64'hC3FC000003FFFFFF; - y = 64'h3FE0000000000000; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC3EC000003FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1339747\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'hCA6F7FFFFFFFDFFF; - zrf = 64'hCAEDFFFFFFF7FFFF; - ans = 64'hCAEE1F7FFFF7FFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1340361\n"); - end - xrf = 64'hC1C0100000001FFE; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'hBC0F7F3C05E5F2B0; - ans = 64'hC1C0100000001FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1340975\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'hA4638C58500B961E; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1341589\n"); - end - xrf = 64'h2EF200000000FFFF; - y = 64'h3CA0800003FFFFFF; - zrf = 64'hBFC8001000000000; - ans = 64'hBFC8001000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1342203\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h3FF0000000000000; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBCA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1342817\n"); - end - xrf = 64'hBFE118C580AAF9EC; - y = 64'h000F808000000000; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1343431\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hA79000000003FF7F; - ans = 64'h3FFFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1344045\n"); - end - xrf = 64'h401FFDFFFFEFFFFE; - y = 64'h0AD00000000003EE; - zrf = 64'hA4CBFFFFFFFFFF7F; - ans = 64'hA4CBFFFFFFFFFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1344659\n"); - end - xrf = 64'h4D4000000000201F; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'h4D5000000000201E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1345273\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'hD69C0000000000FF; - zrf = 64'h43D00000000007FC; - ans = 64'hD69C0000000000FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1345887\n"); - end - xrf = 64'hBF95B034FF94FE5C; - y = 64'h4000000000000001; - zrf = 64'h40BCE22B0AAE2F5F; - ans = 64'h40BCE2203293AF95; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1346501\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'hE8240000000FFFFF; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'hE8240000000FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1347115\n"); - end - xrf = 64'h0C1E96E5A8F1725B; - y = 64'h41FF800000003FFF; - zrf = 64'h3FDF000100000000; - ans = 64'h3FDF000100000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1347729\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'h400BFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1348343\n"); - end - xrf = 64'hCFBFFF00000FFFFF; - y = 64'h40DC8DDCCA9532BF; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1348957\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h4010000000000001; - zrf = 64'h409FFF7FFFDFFFFE; - ans = 64'h40A007BFFFEFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1349571\n"); - end - xrf = 64'hB7F000000000FFF7; - y = 64'h7FD00003FFFFFFEF; - zrf = 64'h4110004040000000; - ans = 64'hF7D000040000FFE6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1350185\n"); - end - xrf = 64'hFFEFFDFFFFFE0000; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hC000000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1350799\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h3FEFF00000000FFF; - zrf = 64'h41FFFFFDFFFFF7FF; - ans = 64'h41FFFFFE000FEFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1351413\n"); - end - xrf = 64'h3FFFFFFFFFFFFFF7; - y = 64'h4340000000000000; - zrf = 64'hBB4FFFFBFFFFE000; - ans = 64'h434FFFFFFFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1352027\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h3D20000007FFFFFE; - zrf = 64'h3CA0000000000000; - ans = 64'h3D20100007FFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1352641\n"); - end - xrf = 64'h3C10004003FFFFFF; - y = 64'h3F0D38A39B792D42; - zrf = 64'h002C000000FFFFFF; - ans = 64'h3B2D39188555C40C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1353255\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'hBFD0000000000000; - ans = 64'h434FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1353869\n"); - end - xrf = 64'hBFCFFF8000FFFFFF; - y = 64'h000F800000000007; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1354483\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h7FE0000000000000; - zrf = 64'h480FFF0003FFFFFE; - ans = 64'h7FDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1355097\n"); - end - xrf = 64'hC0100401FFFFFFFF; - y = 64'h47F479040FA5F423; - zrf = 64'hC0A638D6A77E342F; - ans = 64'hC8147E24DFCA5F93; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1355711\n"); - end - xrf = 64'h47F0007FF8000000; - y = 64'h7FE0000000000001; - zrf = 64'hBFF0000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1356325\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h403E000001FFFFFF; - zrf = 64'h4020008000000000; - ans = 64'h4043002000FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1356939\n"); - end - xrf = 64'hC550008000007FFE; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h3F80000010000800; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1357553\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h469FFFEFFFFFFFBE; - zrf = 64'h0010000000000001; - ans = 64'h469FFFEFFFFFFFBC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1358167\n"); - end - xrf = 64'h401FFFF7FFFFFFFA; - y = 64'h40CF9BE39E1FA5EE; - zrf = 64'hB80010000003FFFF; - ans = 64'h40FF9BDBB726BE60; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1358781\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h7FF0000000000001; - zrf = 64'hBCA0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1359395\n"); - end - xrf = 64'h3FD00003FBFFFFFF; - y = 64'h7FEFFFFFFFE07FFE; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h7FD00003FBF03FFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1360009\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'hBCAFFFEFFFFFFF7F; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1360623\n"); - end - xrf = 64'h4020040000100000; - y = 64'hF7601000000000FF; - zrf = 64'h41CFFFFFFFFFBFE0; - ans = 64'hF7901404001010FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1361237\n"); - end - xrf = 64'hD927210495182481; - y = 64'h8000000000000000; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1361851\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h381FFFFFFFFBFFFF; - zrf = 64'h3FC0100001FFFFFF; - ans = 64'h3FC0100001FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1362465\n"); - end - xrf = 64'hD741116F2A3365CB; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hC06000001FC00000; - ans = 64'hC06000001FC00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1363079\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'hBFD00000007FFFFD; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hBFD00000007FFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1363693\n"); - end - xrf = 64'hC1F000007EFFFFFF; - y = 64'hC3DFFFFFFFDFFEFF; - zrf = 64'hC34C07FFFFFFFFFE; - ans = 64'h45E000007EEFF87C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1364307\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h8010000000000000; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h8027FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1364921\n"); - end - xrf = 64'hFFDD48F3ED90B012; - y = 64'hC26FFF83FFFFFFFE; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1365535\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h800007FFFFFBFFFE; - ans = 64'h802003FFFFFDFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1366149\n"); - end - xrf = 64'hC3FF3FFFFFFFFFFE; - y = 64'h43DFFFFDFFFF7FFF; - zrf = 64'hB4FFFFBFBFFFFFFF; - ans = 64'hC7EF3FFE0BFF82FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1366763\n"); - end - xrf = 64'hC01FFFFFFAFFFFFF; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1367377\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'hC01000FFFFFEFFFF; - zrf = 64'hC34FFFFFFFF803FE; - ans = 64'hC34FFFFFFFF80400; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1367991\n"); - end - xrf = 64'h40B00000001FFBFF; - y = 64'hBCA0000000000001; - zrf = 64'hC1F000007FBFFFFE; - ans = 64'hC1F000007FBFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1368605\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h413EFFF800000000; - zrf = 64'hFFFFFFFFFFFFFFFE; + x = 64'hC0F01FFFFFDFFFFF; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h40500100000FFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -104821,19 +34178,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -104849,12 +34206,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1369219\n"); + $fwrite(fp,"1464177\n"); end - xrf = 64'hC6300001000FFFFF; - y = 64'h434FFFFFFFC0007F; - zrf = 64'h3FFFFFFFFFFFEFEF; - ans = 64'hC9900000FFF0003C; + x = 64'hC80E1FFFFFFFFFFE; + y = 64'h43FFF800000FFFFF; + z = 64'hFFE45DEC7D877F1E; + ans = 64'hFFE45DEC7D877F1E; rn = 1; rz = 0; rm = 0; @@ -104868,19 +34225,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -104896,1374 +34253,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1369833\n"); + $fwrite(fp,"1466191\n"); end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hBCAFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1370447\n"); - end - xrf = 64'h4AAF000007FFFFFF; - y = 64'h0004977D373AAD6E; - zrf = 64'h4010000000000000; - ans = 64'h4010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1371061\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'hBFD0000000000001; - zrf = 64'hBE1001FFFFDFFFFF; - ans = 64'hBFD0000001002000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1371675\n"); - end - xrf = 64'hBABFF7FFFDFFFFFF; - y = 64'hB9B31D4215104245; - zrf = 64'hBFD9CAF56DFECE0A; - ans = 64'hBFD9CAF56DFECE0A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1372289\n"); - end - xrf = 64'h3CA0000000008007; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hBFD0000000000000; - ans = 64'hBFD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1372903\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h00200000000001FC; - zrf = 64'h3F741AB531AC27FD; - ans = 64'h3F741AB531AC27FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1373517\n"); - end - xrf = 64'hC3D000000000407F; - y = 64'hBFE0000000000000; - zrf = 64'hBFD1FFFFFFEFFFFF; - ans = 64'h43C000000000407F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1374131\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'hC6B0000040000008; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1374745\n"); - end - xrf = 64'hBFDFFF7FFFFFBFFF; - y = 64'h7DA199373DE9FB0D; - zrf = 64'h00200001FFFFFFFA; - ans = 64'hFD9198F0D90CE032; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1375359\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h8000000000000000; - ans = 64'hBFEFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1375973\n"); - end - xrf = 64'h3CFD9E68D58E5F29; - y = 64'h430F52E00863ED5B; - zrf = 64'h4000000000000001; - ans = 64'h40227F156C138BF2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1376587\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'hBFF0000000000000; - zrf = 64'hC3D00000000000BF; - ans = 64'hC3D00000000000BF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1377201\n"); - end - xrf = 64'hC1E4000000800000; - y = 64'hE56FC00000000008; - zrf = 64'hC5B036279681DACA; - ans = 64'h6763D800007F0005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1377815\n"); - end - xrf = 64'h4033A8D422040365; - y = 64'hBFF0000000000001; - zrf = 64'hBCA0000000000001; - ans = 64'hC033A8D422040366; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1378429\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'hBCE0000040000000; - zrf = 64'hC340000000040007; - ans = 64'hC340000000040007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1379043\n"); - end - xrf = 64'hBFFF800400000000; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h8A809F84BB94C49F; - ans = 64'h400F8003FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1379657\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'hC03FFFFFFFF0FFFF; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1380271\n"); - end - xrf = 64'hC1FF310B7E90EE8B; - y = 64'hC02FFFFFFBBFFFFF; - zrf = 64'hC1F94758E83D6556; - ans = 64'h423D9C95EBE894AE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1380885\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'hC000000000000001; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1381499\n"); - end - xrf = 64'h7FF0656055BFCC7D; - y = 64'hB9D00001FFFFFFFC; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h7FF8656055BFCC7D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1382113\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h3FD000800000007F; - ans = 64'hC00DFFEFFFFFFFEC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1382727\n"); - end - xrf = 64'hBFCFFC00FFFFFFFF; - y = 64'hC01FFFBFFFBFFFFE; - zrf = 64'h41DFFFFFFFFFFFFF; - ans = 64'h41E00000003FF782; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1383341\n"); - end - xrf = 64'hFFD82E04A44D5219; - y = 64'hC010000000000000; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1383955\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h41D0000004007FFF; - zrf = 64'h47EFFF7FFFFFBFFF; - ans = 64'h47EFFF7FFFFFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1384569\n"); - end - xrf = 64'h47FFFFFFFFFFFFE8; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h7FD002000000007F; - ans = 64'h7FD002000000007F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1385183\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h43DFFFFFFFFC0007; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'h43DFEFFFFFFC0005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1385797\n"); - end - xrf = 64'h800BBE3863B0D8E2; - y = 64'h8D1C310F19AC6C6C; - zrf = 64'h29A000000001F7FF; - ans = 64'h29A000000001F7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1386411\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'hC340000000000000; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1387025\n"); - end - xrf = 64'h40540000001FFFFF; - y = 64'h7AAAE17574EE89CD; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h7B10CCE9692FF795; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1387639\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'hC340000000000001; - zrf = 64'hBE3774044EEB60EB; + x = 64'h3FF0000000000001; + y = 64'h0010000000000000; + z = 64'hC340000000000000; ans = 64'hC340000000000000; rn = 1; rz = 0; @@ -106278,19 +34272,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -106306,999 +34300,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1388253\n"); + $fwrite(fp,"1468205\n"); end - xrf = 64'hA0439A60C9F683F6; - y = 64'hC00FFFFFEFEFFFFE; - zrf = 64'hC7E01000000000FF; - ans = 64'hC7E01000000000FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1388867\n"); - end - xrf = 64'h400000000001FDFF; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hC36000000001FDFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1389481\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h41EFFB7FFFFFFFFE; - zrf = 64'h7FE0000001FF0000; - ans = 64'h7FE0000001FF0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1390095\n"); - end - xrf = 64'hBCBFFFFF7FFFFFFF; - y = 64'hFFE0000000000001; - zrf = 64'hBFEFEFFFFFFFFF7F; - ans = 64'h7CAFFFFF80000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1390709\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'hC3E0000000000000; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC3DFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1391323\n"); - end - xrf = 64'h400B23CD9F2D28D3; - y = 64'h43E00003FFF7FFFF; - zrf = 64'hB8101BFFFFFFFFFF; - ans = 64'h43FB23D46812FEB6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1391937\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1392551\n"); - end - xrf = 64'h2CCFFFFFF9000000; - y = 64'h3E6FFFFFFF000FFF; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1393165\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'hFFF0000000000000; - zrf = 64'h800905798199477F; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1393779\n"); - end - xrf = 64'hB7FFFFFFFFF5FFFF; - y = 64'hBFCFFFFFFF7FFFFC; - zrf = 64'hC60FDFFFFFFFDFFF; - ans = 64'hC60FDFFFFFFFDFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1394393\n"); - end - xrf = 64'hD8FF800000000000; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h8000000000000000; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1395007\n"); - end - xrf = 64'h3FEFFFFFFFFFFFFE; - y = 64'h3FB058526BA0D257; - zrf = 64'h800FFFFE0000007E; - ans = 64'h3FB058526BA0D256; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1395621\n"); - end - xrf = 64'hB81002000000000E; - y = 64'h0000000000000000; - zrf = 64'hBC7C2C58541F1160; - ans = 64'hBC7C2C58541F1160; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1396235\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'hBF1FFFFF7F7FFFFF; - zrf = 64'hC010000000000000; - ans = 64'hC010001FFFFF7F80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1396849\n"); - end - xrf = 64'hC768FA865408D1D8; - y = 64'h3D9294A5362769E9; - zrf = 64'h43FFFFE0000001FE; - ans = 64'hC50D01D665378D9E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1397463\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1398077\n"); - end - xrf = 64'hB4DCF901BB92E4A0; - y = 64'h3E2FEDFFFFFFFFFF; - zrf = 64'h3FD0000000000001; - ans = 64'h3FD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1398691\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h3D500008000007FE; - ans = 64'h3D500008000007FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1399305\n"); - end - xrf = 64'h41FDFFFFFFFFFFEF; - y = 64'h606BF7FFFFFFFFFE; - zrf = 64'h41DCFE3F1CFBA018; - ans = 64'h627A387FFFFFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1399919\n"); - end - xrf = 64'h4020000804000000; - y = 64'h0010000000000001; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1400533\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h8A10800000000003; - zrf = 64'hBD0FF000FFFFFFFF; - ans = 64'hBD0FF000FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1401147\n"); - end - xrf = 64'h402FFFFFFF800002; + x = 64'h403FFFFFF7FFFFFD; y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hC3C8EA6925A562CF; - ans = 64'hC3C8EA6925A562CF; + z = 64'h40055A4532CA591F; + ans = 64'h40055A4532CA591F; rn = 1; rz = 0; rm = 0; @@ -107312,19 +34319,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -107340,12 +34347,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1401761\n"); + $fwrite(fp,"1470219\n"); end - xrf = 64'h3FF0000000000000; - y = 64'h381FFEFFFFFFFFFD; - zrf = 64'hC000000000000001; - ans = 64'hC000000000000001; + x = 64'h117FFFFFFFFF7EFF; + y = 64'h063EFDF9A33EF277; + z = 64'h001FFFFC000FFFFF; + ans = 64'h001FFFFC000FFFFF; rn = 1; rz = 0; rm = 0; @@ -107359,19 +34366,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -107387,247 +34394,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1402375\n"); + $fwrite(fp,"1472233\n"); end - xrf = 64'h41C03474E092DF19; - y = 64'hB887A3DBAEE7821E; - zrf = 64'h43D0000004000003; - ans = 64'h43D0000004000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1402989\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h3CA0000000000001; - zrf = 64'h4010000000000001; - ans = 64'h4010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1403603\n"); - end - xrf = 64'h3CAFFFFFFF00007E; - y = 64'hCABFFFFFEFFBFFFE; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hC77FFFFFEEFC007D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1404217\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hAB4FFFFFFFDFFDFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1404831\n"); - end - xrf = 64'hBFEFFFC0001FFFFF; - y = 64'hC390040000000000; - zrf = 64'h7FF0000000000060; - ans = 64'h7FF8000000000060; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1405445\n"); - end - xrf = 64'hEE6001FFFDFFFFFE; + x = 64'h3FF0000000000001; y = 64'h3FD0000000000000; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -107641,19 +34413,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -107669,12 +34441,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1406059\n"); + $fwrite(fp,"1474247\n"); end - xrf = 64'h3FF0000000000000; - y = 64'h400000000FEFFFFF; - zrf = 64'h37D3F51830BDE67E; - ans = 64'h400000000FEFFFFF; + x = 64'h000454B2B3078D3E; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hC1C3FFFFFFDFFFFF; + ans = 64'hC1C3FFFFFFDFFFFF; rn = 1; rz = 0; rm = 0; @@ -107688,19 +34460,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -107716,12 +34488,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1406673\n"); + $fwrite(fp,"1476261\n"); end - xrf = 64'hBFF9733FD96151F8; - y = 64'h3FD0000000000001; - zrf = 64'h7FD9EFD6C4A0DA0E; - ans = 64'h7FD9EFD6C4A0DA0E; + x = 64'hBF71BFB471D6B240; + y = 64'hC3CEFFFFFFFFFFF7; + z = 64'h41FFFFC000000001; + ans = 64'h435131B74E46FCA9; rn = 1; rz = 0; rm = 0; @@ -107735,19 +34507,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -107763,388 +34535,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1407287\n"); + $fwrite(fp,"1478275\n"); end - xrf = 64'h3FF0000000000000; - y = 64'h480EF55E4C511072; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'h480EF55E4C511072; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1407901\n"); - end - xrf = 64'hEDD07FFC00000000; - y = 64'h0CDE33B29AF512B6; - zrf = 64'h7FF0000000800080; - ans = 64'h7FF8000000800080; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1408515\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h3FE0000000000000; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h4012000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1409129\n"); - end - xrf = 64'h7FEFFFFFFFE7FFFF; - y = 64'h403000FFFFFFFF7F; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1409743\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h3FE0000000000001; - zrf = 64'hC7FFFFFFFF8007FF; - ans = 64'hC7FFFFFFFF8007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1410357\n"); - end - xrf = 64'hC1EFFFFE007FFFFF; - y = 64'h7E5F7FFFFF000000; - zrf = 64'hC048000001000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1410971\n"); - end - xrf = 64'h000FFEEFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1411585\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h41AFFFC000FFFFFF; - zrf = 64'hBFFFFFFE000001FF; - ans = 64'h41AFFFBFFD00003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1412199\n"); - end - xrf = 64'h43CFF740660B0295; + x = 64'h3FF0000000000001; y = 64'h3FF0000000000000; - zrf = 64'h3FC97D303536B448; - ans = 64'h43CFF740660B0295; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3FF0000000000002; rn = 1; rz = 0; rm = 0; @@ -108158,19 +34554,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -108186,12 +34582,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1412813\n"); + $fwrite(fp,"1480289\n"); end - xrf = 64'h3FF0000000000000; - y = 64'h380FEFFFFFFFFF80; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hBFEFFFFFFFFFFFFE; + x = 64'hC3D00000FFFFFFF8; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFBFFFFF6; + ans = 64'h7FFFFFFFFBFFFFF6; rn = 1; rz = 0; rm = 0; @@ -108205,19 +34601,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -108233,12 +34629,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1413427\n"); + $fwrite(fp,"1482303\n"); end - xrf = 64'h4511DFFFFFFFFFFF; - y = 64'h401000000010007E; - zrf = 64'h001FBFFFFFFFFFFE; - ans = 64'h4531E0000011E08C; + x = 64'h3FE919F7AC33ADBE; + y = 64'h4060003000000000; + z = 64'h47646D77AB0D9F00; + ans = 64'h47646D77AB0D9F00; rn = 1; rz = 0; rm = 0; @@ -108252,19 +34648,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -108280,294 +34676,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1414041\n"); + $fwrite(fp,"1484317\n"); end - xrf = 64'h3FF0000000000000; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1414655\n"); - end - xrf = 64'hC46FFFFFF801FFFF; - y = 64'h5F5FFFFFFC00FFFF; - zrf = 64'h0010000000000000; - ans = 64'hE3DFFFFFF402FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1415269\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h4000000000000000; - zrf = 64'h36E02000000003FF; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1415883\n"); - end - xrf = 64'h802FFFFFFFFDFDFF; - y = 64'hA1620FFFFFFFFFFE; - zrf = 64'h3FFFFFFFBFFFFEFE; - ans = 64'h3FFFFFFFBFFFFEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1416497\n"); - end - xrf = 64'hC1DE99F9DE1E2571; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h4340000000000000; - ans = 64'h433FFFFE1660621E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1417111\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h919FFFFFDFBFFFFF; - zrf = 64'h4A9FFFF7FFFF0000; - ans = 64'h4A9FFFF7FFFF0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1417725\n"); - end - xrf = 64'hDB31E4BC02F84EE3; + x = 64'h3FF0000000000001; y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h40000003FFBFFFFE; - ans = 64'hDB51E4BC02F84EE2; + z = 64'hBFF0000000000001; + ans = 64'h4007FFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -108581,19 +34695,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -108609,106 +34723,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1418339\n"); + $fwrite(fp,"1486331\n"); end - xrf = 64'h3FF0000000000000; - y = 64'h3806052FB3CF6049; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1418953\n"); - end - xrf = 64'hC7F0000003F00000; - y = 64'hBF3EFFFFFFFFFFDE; - zrf = 64'hBF9FFFFFF7FFFFFB; - ans = 64'h473F000007A0FFDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1419567\n"); - end - xrf = 64'h3FF0000000000000; + x = 64'h3D80000800003FFF; y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h3FF0000000000000; - ans = 64'h4022000000000000; + z = 64'h3B40000000000037; + ans = 64'h3DB0000800005FFE; rn = 1; rz = 0; rm = 0; @@ -108722,19 +34742,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -108750,12 +34770,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1420181\n"); + $fwrite(fp,"1488345\n"); end - xrf = 64'h7FDFFFFDFFFFFEFF; - y = 64'hC2D5D0A345929279; - zrf = 64'h0000000000000001; - ans = 64'hFFF0000000000000; + x = 64'hBA2DFFFFFFFFFFFB; + y = 64'hB7E70CD81A296791; + z = 64'h419A49C35CF1439E; + ans = 64'h419A49C35CF1439E; rn = 1; rz = 0; rm = 0; @@ -108769,19 +34789,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -108797,5605 +34817,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1420795\n"); + $fwrite(fp,"1490359\n"); end - xrf = 64'h3FF0000000000000; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h3FF0001FFFFF7FFE; - ans = 64'h40220003FFFFEFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1421409\n"); - end - xrf = 64'hC023FFFFFF7FFFFF; - y = 64'h000FFFFEEFFFFFFF; - zrf = 64'hC1801FF000000000; - ans = 64'hC1801FF000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1422023\n"); - end - xrf = 64'h3FD8BF5AE69162C4; - y = 64'h4340000000000001; - zrf = 64'h4010000000000001; - ans = 64'h4328BF5AE69162CE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1422637\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h4070041FFFFFFFFE; - zrf = 64'hBD807FFFFFFFFFFF; - ans = 64'h4070041FFFFFFFDD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1423251\n"); - end - xrf = 64'hB7EFFFFEFEFFFFFF; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h816FFFFFFFFFF07E; - ans = 64'hBB4FFFFEFEFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1423865\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h47FBFFDFFFFFFFFF; - zrf = 64'hBFD0000000000001; - ans = 64'h47FBFFDFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1424479\n"); - end - xrf = 64'h000BC447665234B1; - y = 64'hC1E00000020007FE; - zrf = 64'hC37FFFFFF87FFFFF; - ans = 64'hC37FFFFFF87FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1425093\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h7FE0000000000001; - zrf = 64'h3FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1425707\n"); - end - xrf = 64'hC0CF5CA46D9DFF8A; - y = 64'h43D00000004001FF; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1426321\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hC2B20000003FFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1426935\n"); - end - xrf = 64'h283FFFC0000FFFFF; - y = 64'h47EFC01FFFFFFFFE; - zrf = 64'hC1D3A57182FEF829; - ans = 64'hC1D3A57182FEF829; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1427549\n"); - end - xrf = 64'hBA700010007FFFFF; - y = 64'h7FF0000000000000; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1428163\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h48000FFFFBFFFFFF; - zrf = 64'h000FFFC000020000; - ans = 64'h48000FFFFBFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1428777\n"); - end - xrf = 64'h3CAFF80000003FFF; - y = 64'h7FF0000000000001; - zrf = 64'h3FB03FFFFFFFFBFE; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1429391\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h3FEC0000000001FE; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h3FEC0000000001FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1430005\n"); - end - xrf = 64'h4AD000020007FFFF; - y = 64'h419FFF80000003FE; - zrf = 64'hBCAFFBFFFFFFFBFF; - ans = 64'h4C7FFF84000003BC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1430619\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h8000000000000000; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1431233\n"); - end - xrf = 64'h800D1E2B38A9119F; - y = 64'h434F7FF800000000; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1431847\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h8000000000000001; - zrf = 64'h3B61E24154BF7903; - ans = 64'h3B61E24154BF7903; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1432461\n"); - end - xrf = 64'hBFEF00000007FFFF; - y = 64'h7FFFFFFDFFFFFFEF; - zrf = 64'h41CFFFDFFFFFFFF7; - ans = 64'h7FFFFFFDFFFFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1433075\n"); - end - xrf = 64'h3FBFFFFF7FFF0000; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h3FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1433689\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h3801000200000000; - zrf = 64'hB90000000FDFFFFE; - ans = 64'hB8FFFFDE1FBBFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1434303\n"); - end - xrf = 64'hA33FFFFFFFFF000F; - y = 64'h8010000000000000; - zrf = 64'hC02FFFC100000000; - ans = 64'hC02FFFC100000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1434917\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h3FDC0378450D3C17; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h3FDC0378450D3C17; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1435531\n"); - end - xrf = 64'hC3FF00000000001F; - y = 64'h37FDA4C8F7C83ED8; - zrf = 64'hC01FC00004000000; - ans = 64'hC01FC00004000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1436145\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h3CAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1436759\n"); - end - xrf = 64'h7FF164002DF5273F; - y = 64'h3FEFFFFE08000000; - zrf = 64'hFFE0000000000000; - ans = 64'h7FF964002DF5273F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1437373\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'hBCA0000000000000; - zrf = 64'hFFFF87FFFFFFFFFE; - ans = 64'hFFFF87FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1437987\n"); - end - xrf = 64'h400000000001FFEE; - y = 64'hC3FFF00000020000; - zrf = 64'h40F00FE000000000; - ans = 64'hC40FF0000005FDD4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1438601\n"); - end - xrf = 64'h41FD4494A975008F; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h3FF0000000000000; - ans = 64'h3FEFFFFC576D6AD1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1439215\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'hC4E000008000001F; - zrf = 64'h4AA0000000002003; - ans = 64'h4AA0000000002003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1439829\n"); - end - xrf = 64'h40E000040003FFFE; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hBFEFF80007FFFFFE; - ans = 64'hBFEFF8000800FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1440443\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'hFFFBD39E9E23680E; - zrf = 64'h8010000000000000; - ans = 64'hFFFBD39E9E23680E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1441057\n"); - end - xrf = 64'h0020200001000000; - y = 64'hC3F7520A4E692CBB; - zrf = 64'hC3D00000000007FE; - ans = 64'hC3D00000000007FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1441671\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h3CA0000000000000; - ans = 64'hBFDFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1442285\n"); - end - xrf = 64'hCE300008000FFFFF; - y = 64'h3DFFFFFF800007FF; - zrf = 64'hC340000000000001; - ans = 64'hCC400007C00FE3FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1442899\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h800FFFFFFFFC07FF; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1443513\n"); - end - xrf = 64'hBFDFFFFFFFFEF7FF; - y = 64'hC80FFFFAFFFFFFFF; - zrf = 64'h7FE83123594AADF9; - ans = 64'h7FE83123594AADF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1444127\n"); - end - xrf = 64'h3FBDE21AFA338D84; - y = 64'hBFE0000000000001; - zrf = 64'h3FE0000000000001; - ans = 64'h3FDC43BCA0B98E51; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1444741\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'hAA0159203C3AEEA7; - zrf = 64'h43E00007FFFFFFF6; - ans = 64'h43E00007FFFFFFF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1445355\n"); - end - xrf = 64'hBFBCCDD2E538BE7C; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hC7FFFFC000000003; - ans = 64'hC7FFFFC000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1445969\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'hCA0FFFFFFFFFFFE0; - zrf = 64'h8000000000000001; - ans = 64'hCA0FFFFFFFFFFFE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1446583\n"); - end - xrf = 64'h3EFFFFFFFFFFFF83; - y = 64'hC000000000010010; - zrf = 64'hC0300008001FFFFE; - ans = 64'hC030000C001FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1447197\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'hBFF0000000000001; - zrf = 64'h0010000000000001; - ans = 64'hBFF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1447811\n"); - end - xrf = 64'h43FFFFFFFFEFFFFE; - y = 64'hC7EBFFFFFFFFFFF7; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hCBFBFFFFFFF1FFF5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1448425\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h5B8FFFFC00000040; - ans = 64'h5B8FFFFC00000040; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1449039\n"); - end - xrf = 64'h41C00000023FFFFF; - y = 64'h402FFF8000003FFF; - zrf = 64'h43EFFFFFF6FFFFFF; - ans = 64'h43EFFFFFF73FFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1449653\n"); - end - xrf = 64'h3CA6A6F59CD6ED19; - y = 64'hC000000000000000; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FDFFFFFFFFFFFF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1450267\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h062F7D4B3A2E44A3; - zrf = 64'h1390007FFFFBFFFF; - ans = 64'h1390007FFFFBFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1450881\n"); - end - xrf = 64'hB5D0000000007FFF; - y = 64'hC000000000000001; - zrf = 64'h42800000200000FF; - ans = 64'h42800000200000FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1451495\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'hC3F0007FFFFFFFEF; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1452109\n"); - end - xrf = 64'h37FC68F2C9551242; - y = 64'hBFE8000000001000; - zrf = 64'hC0FFFFFFF7FC0000; - ans = 64'hC0FFFFFFF7FC0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1452723\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'hC010000000000000; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1453337\n"); - end - xrf = 64'h414000007DFFFFFE; - y = 64'hBFC00000207FFFFE; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC11000109E8000FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1453951\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'hC010000000000001; - zrf = 64'hC1FFFFFFFE000001; - ans = 64'hC1FFFFFFFE400001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1454565\n"); - end - xrf = 64'h42B0007FFFFFFFFF; - y = 64'hB7EBFFFF00000000; - zrf = 64'hBFDFFFFFFFFFBFFE; - ans = 64'hBFDFFFFFFFFFBFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1455179\n"); - end - xrf = 64'h802B8498753EDE4C; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h3CAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1455793\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'hBFF0800000000200; - zrf = 64'h3FE0082000000000; - ans = 64'hBFE0F7E000000400; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1456407\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hC340000000000000; - zrf = 64'hBFD000FBFFFFFFFF; - ans = 64'hC36FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1457021\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'hC3D001FFFFDFFFFF; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1457635\n"); - end - xrf = 64'hBCA61E84606C3423; - y = 64'h60BFFFFFFFFFFF9E; - zrf = 64'hC3D000007FDFFFFF; - ans = 64'hDD761E84606C33DF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1458249\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1458863\n"); - end - xrf = 64'hC6E007FFFFFFFFFD; - y = 64'h41DD22A3BDB366AB; - zrf = 64'hC000000000000000; - ans = 64'hC8CD31350F924059; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1459477\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'hFFE0000000000000; - zrf = 64'hC02200001FFFFFFE; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1460091\n"); - end - xrf = 64'hFFE4CA029067CDD2; - y = 64'hC3DBFFDFFFFFFFFF; - zrf = 64'h465BFFFFFFF7FFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1460705\n"); - end - xrf = 64'hBFF0009000000000; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h3CA0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1461319\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'hBFCDFFFFFEFFFFFF; - zrf = 64'h262981240D4CABCB; - ans = 64'hBFCDFFFFFEFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1461933\n"); - end - xrf = 64'hB7E0000FFFFFFFEE; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h3FBFFFFFF00003FE; - ans = 64'h77E0000FFFFFFFED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1462547\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'h5B30000000081FFF; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1463161\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h3DBFFFFFFFFFFFFE; - zrf = 64'hBFE7BC400C829841; - ans = 64'hBFE7BC400C849841; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1463775\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'hFFF0000000000001; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1464389\n"); - end - xrf = 64'hC014558C41993437; - y = 64'h3FFFFFFFFFF80007; - zrf = 64'hBFF0000000000001; - ans = 64'hC026558C41941ED9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1465003\n"); - end - xrf = 64'h3FF0000000000000; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h7FDFFEFF7FFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1465617\n"); - end - xrf = 64'hFFE000100007FFFF; - y = 64'hC1EFFFFFFFFFF9FE; - zrf = 64'h41EFFFFAFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1466231\n"); - end - xrf = 64'hBFD0002000007FFF; - y = 64'h0000000000000001; - zrf = 64'h0010000000000001; - ans = 64'h0010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1466845\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h401FFFEFFFFFFE00; - zrf = 64'hB7E0001FFFFFFFF0; - ans = 64'h401FFFEFFFFFFE02; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1467459\n"); - end - xrf = 64'h4030000800000002; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h3FD6420B9320937C; - ans = 64'h3FD6420B9320937C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1468073\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'hC02FFFFFFF800000; - zrf = 64'h4340000000000001; - ans = 64'h433FFFFFFFFFFFF2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1468687\n"); - end - xrf = 64'hC33D09CE5D5C2E97; - y = 64'h37E00000007FFBFF; - zrf = 64'h3FB0000007FFDFFF; - ans = 64'h3FB0000007FFDFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1469301\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h0010000000000000; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1469915\n"); - end - xrf = 64'h3CA0003FFFDFFFFF; - y = 64'h51B0001FFFFFE000; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'h4E600060005FDFBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1470529\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h41E2741C57480754; - ans = 64'h41E2741C57480754; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1471143\n"); - end - xrf = 64'hC5C0000400000FFE; - y = 64'h282FFFEFFFFFBFFF; - zrf = 64'hBE6FFFBFFFFFFFFF; - ans = 64'hBE6FFFBFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1471757\n"); - end - xrf = 64'hC1FFFFFFFFFFFFBB; - y = 64'h3CA0000000000000; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hBEAFFFFFFFFFFFBB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1472371\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h43D8225B6AFE04F2; - zrf = 64'h3FDFFE00000007FE; - ans = 64'h43D8225B6AFE04F4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1472985\n"); - end - xrf = 64'hBF9FFFF807FFFFFE; - y = 64'h3CA0000000000001; - zrf = 64'hBF90002003FFFFFF; - ans = 64'hBF90002004000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1473599\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'hC30FFDFFFFFFFDFF; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'hC30FFDFFFFFFFDC1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1474213\n"); - end - xrf = 64'hBED0001000200000; - y = 64'hBFC000000004000E; - zrf = 64'h434FFFFFFFFFFF01; - ans = 64'h434FFFFFFFFFFF01; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1474827\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1475441\n"); - end - xrf = 64'h3D0FFE7FFFFFFFFE; - y = 64'hBBCE249A24D994EE; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1476055\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h3FD0000000000001; - zrf = 64'h6DBF7BFFFFFFFFFF; - ans = 64'h6DBF7BFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1476669\n"); - end - xrf = 64'h427FF80001FFFFFF; - y = 64'hB810FFFFFE000000; - zrf = 64'h4721FBFFFFFFFFFE; - ans = 64'h4721FBFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1477283\n"); - end - xrf = 64'hC3F0000000200800; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1477897\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h403000001FFF0000; - zrf = 64'h381EFFFFFFBFFFFF; - ans = 64'h403000001FFF0001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1478511\n"); - end - xrf = 64'h3EF0004000040000; - y = 64'h3FE0000000000000; - zrf = 64'h3FCFFFFFFFEFFFFF; - ans = 64'h3FD0002000780008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1479125\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'hBFC000000007FFF7; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h400EFFFFFFFF7FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1479739\n"); - end - xrf = 64'h151288F63CC0F407; - y = 64'hC3A078EE7C1CA23C; - zrf = 64'h37E0000400000FFF; - ans = 64'h37E0000400000FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1480353\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01BFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1480967\n"); - end - xrf = 64'h7FF00000F8000000; - y = 64'hC3E00FFFFFFFFFFF; - zrf = 64'hBFD0000000000000; - ans = 64'h7FF80000F8000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1481581\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h3FF0000000000000; - zrf = 64'hBFFFF7FFF7FFFFFF; - ans = 64'hBFEFEFFFEFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1482195\n"); - end - xrf = 64'h4390001001FFFFFF; - y = 64'h41F00000400003FF; - zrf = 64'h73614A879212B060; - ans = 64'h73614A879212B060; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1482809\n"); - end - xrf = 64'h21700040000001FF; - y = 64'h3FF0000000000001; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1483423\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h4F41C01D1EBD97EE; - zrf = 64'h4030AF30C9E22201; - ans = 64'h4F41C01D1EBD97EF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1484037\n"); - end - xrf = 64'hB300000000000000; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hC03FFE003FFFFFFF; - ans = 64'hC03FFE003FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1484651\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h081000003FFFFDFF; - zrf = 64'h4000000000000000; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1485265\n"); - end - xrf = 64'h422000040001FFFE; - y = 64'hC1D4CBE79C60598B; - zrf = 64'h068EEFFFFFFFFFFE; - ans = 64'hC404CBECCF5CDA1D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1485879\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h4000000000000001; - zrf = 64'hC010000000000000; - ans = 64'hBFFFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1486493\n"); - end - xrf = 64'h0020000000BFFFFF; - y = 64'hC008D81E79C4BDF1; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1487107\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hC80C000000003FFF; - ans = 64'hC80C000000003FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1487721\n"); - end - xrf = 64'h402000001FFFFFFB; - y = 64'hBFD00003FFDFFFFF; - zrf = 64'hBFFFFFFC00000010; - ans = 64'hC01000010FF00401; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1488335\n"); - end - xrf = 64'h3F9FFFFFC00FFFFF; - y = 64'h4010000000000000; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1488949\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h12E0002000000000; - zrf = 64'h438FBFFFFFFEFFFF; - ans = 64'h438FBFFFFFFEFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1489563\n"); - end - xrf = 64'h434FF80001FFFFFF; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h2FEFFFFBF7FFFFFF; - ans = 64'h437FF80001FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1490177\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h93120000003FFFFF; - zrf = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1490791\n"); - end - xrf = 64'hB7EFFFFFFFFFFFF1; - y = 64'hC1C946962E1C5437; - zrf = 64'hB3BF8000007FFFFF; - ans = 64'h39C946962E1C542B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1491405\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h4340000000000000; - zrf = 64'hC000000000000001; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1492019\n"); - end - xrf = 64'hC05FFFFFFE0001FE; - y = 64'hC033FB5821777B64; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h40A3FB582037C720; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1492633\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'hFFDFFFFFA0000000; - ans = 64'hFFDFFFFFA0000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1493247\n"); - end - xrf = 64'hBFE0000082000000; - y = 64'h3F00000000000010; - zrf = 64'h3FEE3E1841C696F0; - ans = 64'h3FEE3DF841C592F0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1493861\n"); - end - xrf = 64'hBFE0000100FFFFFF; + x = 64'h3FF0000000000001; y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC3580000807FFFFE; + z = 64'h4340000000000000; + ans = 64'h4358000000000000; rn = 1; rz = 0; rm = 0; @@ -114409,19 +34836,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -114437,59 +34864,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1494475\n"); + $fwrite(fp,"1492373\n"); end - xrf = 64'h3FF0000000000001; - y = 64'hC0096863BF8D68B1; - zrf = 64'h8D53FFFFFFFF7FFF; - ans = 64'hC0096863BF8D68B3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1495089\n"); - end - xrf = 64'h4130FFFFFFFFFFF8; + x = 64'h8EA000800007FFFE; y = 64'h7FE0000000000001; - zrf = 64'h400757A0F4028052; - ans = 64'h7FF0000000000000; + z = 64'hCC6000000200000F; + ans = 64'hCE9000800009FFFF; rn = 1; rz = 0; rm = 0; @@ -114503,19 +34883,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -114531,12 +34911,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1495703\n"); + $fwrite(fp,"1494387\n"); end - xrf = 64'h3FF0000000000001; - y = 64'hFFE598A2EFE0CC56; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'hFFE598A2EFE0CC57; + x = 64'h4000010000000000; + y = 64'hBBB3FFFFDFFFFFFF; + z = 64'h3FD4000000000000; + ans = 64'h3FD4000000000000; rn = 1; rz = 0; rm = 0; @@ -114550,19 +34930,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -114578,246 +34958,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1496317\n"); + $fwrite(fp,"1496401\n"); end - xrf = 64'hBF8FFFFF0000FFFF; - y = 64'hCAAFFFFFFFFDEFFE; - zrf = 64'hBFB6E9A88034930A; - ans = 64'h4A4FFFFEFFFEEFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1496931\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1497545\n"); - end - xrf = 64'h43D0000000087FFF; - y = 64'hD7B36A7D8CEAEBE7; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hDB936A7D8CF53C78; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1498159\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h7FF0000000000001; - zrf = 64'hBCA0007FFFFFFFEF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1498773\n"); - end - xrf = 64'hC03FFF000000000F; - y = 64'h403FFFF8000003FF; - zrf = 64'h37F00800003FFFFF; - ans = 64'hC08FFEF80040040E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1499387\n"); - end - xrf = 64'h4030000000FFBFFF; + x = 64'h3FF0000000000001; y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'hC01FFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -114832,19 +34977,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -114860,12 +35005,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1500001\n"); + $fwrite(fp,"1498415\n"); end - xrf = 64'h3FF0000000000001; - y = 64'h403FFFF0000000FF; - zrf = 64'hD4F00013FFFFFFFF; - ans = 64'hD4F00013FFFFFFFF; + x = 64'h380FFFFF7DFFFFFE; + y = 64'h8000000000000001; + z = 64'h3757EB54C3BC586F; + ans = 64'h3757EB54C3BC586F; rn = 1; rz = 0; rm = 0; @@ -114879,19 +35024,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -114907,12 +35052,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1500615\n"); + $fwrite(fp,"1500429\n"); end - xrf = 64'hC6DA302F95D53E41; - y = 64'h8000000000000000; - zrf = 64'h3A8FF7FFFE000000; - ans = 64'h3A8FF7FFFE000000; + x = 64'hBDDFFF81FFFFFFFF; + y = 64'hBF4FFFFFFFF7FFBE; + z = 64'h0CEFFEDFFFFFFFFE; + ans = 64'h3D3FFF81FFF7FFDD; rn = 1; rz = 0; rm = 0; @@ -114926,19 +35071,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -114954,2831 +35099,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1501229\n"); + $fwrite(fp,"1502443\n"); end - xrf = 64'h3FF0000000000001; - y = 64'hBCA7FFFFFEFFFFFE; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FDFFFFFFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1501843\n"); - end - xrf = 64'h3FBFFFFFFDFF7FFE; - y = 64'hC7EFFFFE00020000; - zrf = 64'h43AFFFFF8003FFFE; - ans = 64'hC7BFFFFDFE01801E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1502457\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hBFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1503071\n"); - end - xrf = 64'h0003476357EBF517; - y = 64'h7FE000004000003F; - zrf = 64'h8000000000000000; - ans = 64'h3FDA3B1B284C141D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1503685\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h8010000000000000; - zrf = 64'hFFF71E22014210B7; - ans = 64'hFFFF1E22014210B7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1504299\n"); - end - xrf = 64'hB7F00000FFFFFFBF; - y = 64'hB81E94EC16510659; - zrf = 64'hE5900000000000FC; - ans = 64'hE5900000000000FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1504913\n"); - end - xrf = 64'h255FC00010000000; - y = 64'h8010000000000001; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1505527\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'hC7E00000FFFFDFFF; - zrf = 64'hBFCDFFFC00000000; - ans = 64'hC7E00000FFFFE000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1506141\n"); - end - xrf = 64'h381FEFFDFFFFFFFF; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'hFFF0207FFFFFFFFF; - ans = 64'hFFF8207FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1506755\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h406333A1C67874F2; - zrf = 64'h3FD0000000000000; - ans = 64'h40633BA1C67874F3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1507369\n"); - end - xrf = 64'h3F8000003FFBFFFF; - y = 64'hB3FFF8003FFFFFFF; - zrf = 64'h3CA5CDFC371469D5; - ans = 64'h3CA5CDFC371469D5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1507983\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'hBCA0000000000001; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1508597\n"); - end - xrf = 64'hC011000400000000; - y = 64'hC1FEEDF467BB14D3; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1509211\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hB9706068EB130215; - ans = 64'hBCB0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1509825\n"); - end - xrf = 64'h340FFFFFFFFFFFDC; - y = 64'hC3D8682AE89D9DE3; - zrf = 64'hB80FFE0000010000; - ans = 64'hB816190ABA27E772; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1510439\n"); - end - xrf = 64'h3BAFFFFFFFFFFF02; - y = 64'hBFD0000000000000; - zrf = 64'hC000000000000001; - ans = 64'hC000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1511053\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h002FF80008000000; - zrf = 64'h42EFEFFFFFEFFFFF; - ans = 64'h42EFEFFFFFEFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1511667\n"); - end - xrf = 64'h388FFF7FFFFFDFFF; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h63CFFFEBFFFFFFFF; - ans = 64'h63CFFFEBFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1512281\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h480008000000000F; - zrf = 64'h3CA0000000000001; - ans = 64'h4800080000000010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1512895\n"); - end - xrf = 64'hC04000001001FFFE; - y = 64'h3FD00E1A7AB10717; - zrf = 64'hBE9CEA205823E383; - ans = 64'hC0200E1A9936337F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1513509\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'hBFE0000000000000; - zrf = 64'hBFD0000000000001; - ans = 64'hBFE8000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1514123\n"); - end - xrf = 64'h3E8FFFFF7FFFFDFF; - y = 64'hB80FFFFEFFFBFFFE; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1514737\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h7FD0001FFFFFC000; - ans = 64'h7FD0001FFFFFC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1515351\n"); - end - xrf = 64'h43DFFFFFFFFFBFEF; - y = 64'hC0100000BFFFFFFF; - zrf = 64'hBCA00FFF7FFFFFFF; - ans = 64'hC4000000BFFFDFF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1515965\n"); - end - xrf = 64'h3DBF001FFFFFFFFE; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hC00000000000F800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1516579\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'hBFCFF7FFFDFFFFFF; - zrf = 64'hBFE000000007FFFB; - ans = 64'hBFE7FDFFFF87FFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1517193\n"); - end - xrf = 64'h43E0001000001000; - y = 64'hBFF0000000000001; - zrf = 64'hC0F092135375188F; - ans = 64'hC3E0001000001022; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1517807\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'hB81F7FFFFFFFFFBE; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'hB81F7FFFFFFFFFC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1518421\n"); - end - xrf = 64'hBF20000000003FEF; - y = 64'hA550A89F56EB2FAD; - zrf = 64'hC00003FFF7FFFFFF; - ans = 64'hC00003FFF7FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1519035\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1519649\n"); - end - xrf = 64'h3FDFBFFFFFFFFDFF; - y = 64'hBFC0000000005FFE; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1520263\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'hC000000000000001; - zrf = 64'h41BFFFE001FFFFFF; - ans = 64'h41BFFFDFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1520877\n"); - end - xrf = 64'hC3FFC003FFFFFFFF; - y = 64'h802F6AF6024C08B5; - zrf = 64'h3FEFFFFFF80FFFFE; - ans = 64'h3FEFFFFFF80FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1521491\n"); - end - xrf = 64'h4770000000017FFE; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hC790000000017FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1522105\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'hBFD40001FFFFFFFE; - zrf = 64'hC04007FFFFFFFBFF; - ans = 64'hC040300003FFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1522719\n"); - end - xrf = 64'h41D566DE1FA9698E; - y = 64'hC010000000000000; - zrf = 64'h3FC01FFFFFFDFFFE; - ans = 64'hC1F566DE1FA7658E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1523333\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h47F4831548A0898D; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h47F4831548A0898E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1523947\n"); - end - xrf = 64'h434000000021FFFF; - y = 64'hC1CFFFFFFFFF7FF7; - zrf = 64'h37F0080080000000; - ans = 64'hC52000000021BFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1524561\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'hC020000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1525175\n"); - end - xrf = 64'h7E6FFFF80000007F; - y = 64'h37E0008FFFFFFFFE; - zrf = 64'h4340000000000000; - ans = 64'h7660008BFFDC003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1525789\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'hC340000000000000; - zrf = 64'hC770000000023FFF; - ans = 64'hC770000000023FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1526403\n"); - end - xrf = 64'hE9500000001FFFFF; - y = 64'hC00BFFFFF7FFFFFF; - zrf = 64'h2EDBFFFFFFFC0000; - ans = 64'h696BFFFFF837FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1527017\n"); - end - xrf = 64'h47F000003FFFFFE0; - y = 64'hC340000000000001; - zrf = 64'hBFE0000000000000; - ans = 64'hCB4000003FFFFFE1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1527631\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'hAA790F9E140279B6; - zrf = 64'h3FE08000000FFFFF; - ans = 64'h3FE08000000FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1528245\n"); - end - xrf = 64'hC0A007FFFEFFFFFE; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hB810000004000003; - ans = 64'h440007FFFEFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1528859\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h3FC7F50DD5148BA7; - zrf = 64'h0000000000000000; - ans = 64'h3FC7F50DD5148BA8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1529473\n"); - end - xrf = 64'h4698040000000000; - y = 64'h37FFEFFFFFFFBFFF; - zrf = 64'h200000FBFFFFFFFF; - ans = 64'h3EA7F7FDFFFFCFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1530087\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'hFFE0000000000001; - zrf = 64'h8010000000000000; - ans = 64'hFFE0000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1530701\n"); - end - xrf = 64'h790000100000001F; - y = 64'hC2D58B4193E58B37; - zrf = 64'h4010000000000001; - ans = 64'hFBE58B571F271F46; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1531315\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h40769FBEEA3D4736; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1531929\n"); - end - xrf = 64'hC3E0007FFFFFFFFF; - y = 64'hC0000000000207FF; - zrf = 64'hFFD000000001EFFF; - ans = 64'hFFD000000001EFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1532543\n"); - end - xrf = 64'h3FD3EEE5BED7AEF6; - y = 64'hFFF0000000000000; - zrf = 64'hBFD0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1533157\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'h43EF800400000000; - zrf = 64'hC02FFFFFFFFFFF40; - ans = 64'h43EF800400000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1533771\n"); - end - xrf = 64'hAF94000000003FFF; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h37F000001EFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1534385\n"); - end - xrf = 64'h3FF0000000000001; - y = 64'hB9FF00000003FFFF; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1534999\n"); - end - xrf = 64'hC34439AD7B57B86A; - y = 64'h41CFFFFFFFF807FE; - zrf = 64'h429FFDFFFFFFF000; - ans = 64'hC52439AD7B529F0D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1535613\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h0000000000000000; - zrf = 64'h8000000000000001; - ans = 64'h8000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1536227\n"); - end - xrf = 64'hC02BBD44DD056675; - y = 64'hC1C000000005FFFF; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h41FBBD44DD4FCD6D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1536841\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h3FBFFFE001FFFFFF; - ans = 64'h3FBFFFE001FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1537455\n"); - end - xrf = 64'h3CAFFFFFFF83FFFF; - y = 64'h37E00003FFFFFFDE; - zrf = 64'h40200000003FFFF7; - ans = 64'h40200000003FFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1538069\n"); - end - xrf = 64'h3F1000047FFFFFFE; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hBCAFFFFFFFFFFFFF; + x = 64'h3FF0000000000001; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; ans = 64'hBCAFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -117793,19 +35118,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -117821,3020 +35146,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1538683\n"); + $fwrite(fp,"1504457\n"); end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h43F2459EC8CC5AA8; - zrf = 64'hBFBC00D7CE203DB4; - ans = 64'h4402459EC8CC5AA7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1539297\n"); - end - xrf = 64'h380FFFFFFF7FF7FE; - y = 64'h0010000000000001; - zrf = 64'hFFEFFFFFFFFFF80F; - ans = 64'hFFEFFFFFFFFFF80F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1539911\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h43C010001FFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1540525\n"); - end - xrf = 64'h41D00FFFFFFFFFFB; - y = 64'hA8FC400000000000; - zrf = 64'h4051000000001FFF; - ans = 64'h4051000000001FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1541139\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1541753\n"); - end - xrf = 64'h454000000000FF7E; - y = 64'hC3CFFFFDFFFFFF80; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'hC91FFFFE0001FE7C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1542367\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h3CA0000000000001; - zrf = 64'h98800000400000FF; - ans = 64'h3CB0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1542981\n"); - end - xrf = 64'hD90077FFFFFFFFFF; - y = 64'h41CFFFFFFFFFFFFF; - zrf = 64'h3FEFFFFFFFFF7FFD; - ans = 64'hDAE077FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1543595\n"); - end - xrf = 64'h37FFFFFC000007FF; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h34BFFFFC000007FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1544209\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hFFAFFFFFFFBFFDFE; - zrf = 64'h3FE2863660754A51; - ans = 64'hFFBFFFFFFFBFFDFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1544823\n"); - end - xrf = 64'hB8100000FFFFFDFE; - y = 64'h3FD0000000000000; - zrf = 64'h41C0000800000000; - ans = 64'h41C0000800000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1545437\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h366FFFFE00400000; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1546051\n"); - end - xrf = 64'hA18FDD1E4F1D8794; - y = 64'hE5FE3FFFFFFFFFFF; - zrf = 64'hC1EC6D016FC1B191; - ans = 64'h479E1F06A6C9EA29; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1546665\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1547279\n"); - end - xrf = 64'h3FCFFFF1FFFFFFFF; - y = 64'hB8000001FF7FFFFF; - zrf = 64'h3FF0000000000000; - ans = 64'h3FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1547893\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h3FE0000000000000; - zrf = 64'h0011BC66A6AFD091; - ans = 64'h3FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1548507\n"); - end - xrf = 64'h68A5BD6C73D63CB8; - y = 64'h43D1FFF7FFFFFFFF; - zrf = 64'h3C40008000FFFFFF; - ans = 64'h6C88750F239ACA63; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1549121\n"); - end - xrf = 64'h3CAFFFFFC0000003; - y = 64'h3FE0000000000001; - zrf = 64'h8010000000000000; - ans = 64'h3C9FFFFFC0000005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1549735\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h3F6000023FFFFFFE; - zrf = 64'h7FF00001FFFEFFFE; - ans = 64'h7FF80001FFFEFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1550349\n"); - end - xrf = 64'hBF000000007FE000; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'hBFDFFFFFF5FFFFFF; - ans = 64'hBFE0003FFB0001FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1550963\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hB361F0FC60A5C255; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1551577\n"); - end - xrf = 64'hC0300000002FFFFE; - y = 64'h395FFFEFFFFFFFFF; - zrf = 64'hB95FFFEFFFF7FFFF; - ans = 64'hB9A0FFF7802FBFE5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1552191\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h3FF0000000000001; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1552805\n"); - end - xrf = 64'hA140000000FFFFBE; - y = 64'h40BFFFFF00000007; - zrf = 64'h3FE0000000000001; - ans = 64'h3FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1553419\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h496131E708AD247B; - ans = 64'h496131E708AD247B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1554033\n"); - end - xrf = 64'h40233C8AC990330C; - y = 64'h3E6000000003DFFF; - zrf = 64'h3FD0007FF7FFFFFF; - ans = 64'h3FD000812BC8AC98; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1554647\n"); - end - xrf = 64'hBDD00000000FFFDF; - y = 64'h4000000000000000; - zrf = 64'h8000000000000001; - ans = 64'hBDE00000000FFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1555261\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h7FEB41A3838A8AC9; - zrf = 64'hCBDFFFFFFFD7FFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1555875\n"); - end - xrf = 64'hBE8C8E5F27717F72; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h409000000000FFFC; - ans = 64'h408FFFFFFF8FC67B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1556489\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h3F3FFFFFFEFFFFFF; - zrf = 64'hC010000000000001; - ans = 64'hC00FFE0000001002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1557103\n"); - end - xrf = 64'h7FF8F9996F21B694; - y = 64'hB14FFFFFFFFC001F; - zrf = 64'hD36000000BFFFFFF; - ans = 64'h7FF8F9996F21B694; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1557717\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h4010000000000000; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1558331\n"); - end - xrf = 64'hFFDFFFE01FFFFFFE; - y = 64'h400FFFF3FFFFFFFF; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1558945\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h4010000000000001; - zrf = 64'hC1D3347EDAE48B72; - ans = 64'hC1D3347ED8E48B72; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1559559\n"); - end - xrf = 64'h000ACDCC076E0ADF; - y = 64'h3D6666AA8E1AABE5; - zrf = 64'h403BFFFFFFF7FFFF; - ans = 64'h403BFFFFFFF7FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1560173\n"); - end - xrf = 64'h381000000FFF0000; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1560787\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h3CAF800001FFFFFE; - zrf = 64'h3800000002100000; - ans = 64'h3CBF800001FFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1561401\n"); - end - xrf = 64'hC3EFFFFFDFFFFFFA; - y = 64'h4340000000000001; - zrf = 64'hC680063611833898; - ans = 64'hC740010053611832; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1562015\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hAE79CAC1FE3DF21C; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1562629\n"); - end - xrf = 64'h35200007FFFFE000; - y = 64'hBFBFFFFFFDEFFFFF; - zrf = 64'hBFF6AC5CC5343BAF; - ans = 64'hBFF6AC5CC5343BAF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1563243\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h435FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1563857\n"); - end - xrf = 64'h3FC00FFFFFFFFF7E; - y = 64'hB80000000080003F; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h3CAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1564471\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h7FE0000000000000; - zrf = 64'h9520000001FFFBFE; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1565085\n"); - end - xrf = 64'h3F2BFFFFFFFFFFFD; - y = 64'h80200FFFFFBFFFFE; - zrf = 64'hC1F0000003FBFFFE; - ans = 64'hC1F0000003FBFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1565699\n"); - end - xrf = 64'hEA600000001000FF; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1566313\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hC3FFFFFFFFFFF801; - zrf = 64'hFFF00000FFDFFFFE; - ans = 64'hFFF80000FFDFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1566927\n"); - end - xrf = 64'h37DFE000003FFFFF; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hC04FFFFFFFFFB7FE; - ans = 64'h77DFE000003FFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1567541\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h400FFFE200000000; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'h4017FFE200000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1568155\n"); - end - xrf = 64'hBFCFFFFFFFFFF810; - y = 64'h3FF0000003FFBFFF; - zrf = 64'h41EFF8007FFFFFFF; - ans = 64'h41EFF8007FF7FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1568769\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1569383\n"); - end - xrf = 64'hBC3FFFFFFFFFFC01; - y = 64'hBFD0484EBF02F052; - zrf = 64'h3CA0000000000000; - ans = 64'h3CA010484EBF02EE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1569997\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h00000007FFC00000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1570611\n"); - end - xrf = 64'h43FFFFFFFFFFC001; - y = 64'h47FFB25D4AD4E4DB; - zrf = 64'h3FF0080000000000; - ans = 64'h4C0FB25D4AD4A577; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1571225\n"); - end - xrf = 64'h402F81736BA4D5A0; - y = 64'h8000000000000001; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1571839\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h3FB4004000000000; - zrf = 64'h41631A545858549B; - ans = 64'h41631A545D58649B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1572453\n"); - end - xrf = 64'h41F7FFFFFFFFFFFF; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h41C1C06162ADBF79; - ans = 64'h41C1C06162ADBF79; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1573067\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h3FC00FFFFFFFFE00; - zrf = 64'hBFF0000000000000; - ans = 64'hBFE7F80000000100; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1573681\n"); - end - xrf = 64'h000FFFFFFFFF8004; - y = 64'hBFCFFF8000000001; - zrf = 64'h3FF00000000004FF; - ans = 64'h3FF00000000004FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1574295\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h8010000000000001; - zrf = 64'h4000000000000000; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1574909\n"); - end - xrf = 64'h411FFFC000100000; - y = 64'hBC40004FFFFFFFFE; - zrf = 64'h0010000000000001; - ans = 64'hBD70002FFF680026; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1575523\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h3BE292DF5A68281D; - ans = 64'h3BE292DF5A68281D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1576137\n"); - end - xrf = 64'h3F60401000000000; - y = 64'h294000020000000F; - zrf = 64'h80000407FFFFFFFE; - ans = 64'h28B040120802000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1576751\n"); - end - xrf = 64'h4801FFFFFFFFFFFE; - y = 64'hBCA0000000000000; - zrf = 64'h4340000000000001; - ans = 64'hC4B1FFFFDFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1577365\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hC7E000001001FFFF; - zrf = 64'h309FFFFFFFBFFFF0; - ans = 64'hC7F000001001FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1577979\n"); - end - xrf = 64'hBE203FFFFFF00000; + x = 64'hD32DFFFFFFFFFFFF; y = 64'hBCA0000000000001; - zrf = 64'hC030000000003EFF; - ans = 64'hC030000000003EFF; + z = 64'hBFFDFFFFFDFFFFFE; + ans = 64'h4FDE000000000001; rn = 1; rz = 0; rm = 0; @@ -120848,19 +35165,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -120876,12 +35193,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1578593\n"); + $fwrite(fp,"1506471\n"); end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hC1D0000040FFFFFE; - zrf = 64'hBFE0000000000001; - ans = 64'hC1E00000410FFFFD; + x = 64'h400FFBFFFFFFFFFE; + y = 64'h342FFFFFFF007FFF; + z = 64'h8A1FBFDFFFFFFFFF; + ans = 64'h344FFBFFFF009FED; rn = 1; rz = 0; rm = 0; @@ -120895,19 +35212,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -120923,58 +35240,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1579207\n"); + $fwrite(fp,"1508485\n"); end - xrf = 64'h3A50400000080000; - y = 64'hC7EFFFFF6FFFFFFF; - zrf = 64'hA51FFFFFFFFF7000; - ans = 64'hC2503FFFB6E7FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1579821\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hBFD0000000000000; - zrf = 64'h3FF0000000000001; + x = 64'h3FF0000000000001; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h3FF0000000000001; ans = 64'h3FE0000000000002; rn = 1; rz = 0; @@ -120989,19 +35259,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -121017,247 +35287,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1580435\n"); + $fwrite(fp,"1510499\n"); end - xrf = 64'h8000408000000000; - y = 64'hB7F00001FFFFFE00; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h000FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1581049\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hBFD0000000000001; - zrf = 64'hC02000000080007E; - ans = 64'hC02100000080007E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1581663\n"); - end - xrf = 64'h3280000780000000; - y = 64'h7FD007DFFFFFFFFF; - zrf = 64'h4C8FFFEFDFFFFFFF; - ans = 64'h726007E783B0FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1582277\n"); - end - xrf = 64'hBEAFFFFFFFFFF007; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h402000000FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1582891\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h42DFFDFFFFFFFFFF; - zrf = 64'h3F4FFFFF3FFFFFFF; - ans = 64'h42EFFDFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1583505\n"); - end - xrf = 64'hBFBE000003FFFFFF; + x = 64'h9F17C42487B3329A; y = 64'hBFE0000000000000; - zrf = 64'hAC9FEFFFFFFFFEFF; - ans = 64'h3FAE000003FFFFFF; + z = 64'h4800003FFFFFFFE0; + ans = 64'h4800003FFFFFFFE0; rn = 1; rz = 0; rm = 0; @@ -121271,19 +35306,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -121299,12 +35334,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1584119\n"); + $fwrite(fp,"1512513\n"); end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hC1D0000008000400; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hC1E00000081003FF; + x = 64'hB09000002007FFFF; + y = 64'hC01B59E3519ADF64; + z = 64'h43C00000000007FD; + ans = 64'h43C00000000007FD; rn = 1; rz = 0; rm = 0; @@ -121318,19 +35353,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -121346,18012 +35381,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1584733\n"); + $fwrite(fp,"1514527\n"); end - xrf = 64'hD2B1000000007FFF; - y = 64'hCA8186CC19B70C07; - zrf = 64'hC00EB7E6E75515EB; - ans = 64'h5D429F38DB5308FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1585347\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1585961\n"); - end - xrf = 64'hC0300BFFFFFFFFFE; - y = 64'h744003FFFFFFFFFC; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1586575\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hBFF0000000000000; - zrf = 64'hB7F06F51947E5EFA; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1587189\n"); - end - xrf = 64'hBCAFFFFFFDFEFFFF; - y = 64'hDBDFFFFFFFF5FFFE; - zrf = 64'h45465A4CBC45F897; - ans = 64'h589FFFFFFDF4FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1587803\n"); - end - xrf = 64'h4080000000007DFE; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'hC08FE0000000FBFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1588417\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h3FD02003FFFFFFFF; - zrf = 64'hB80E4FB403E45282; - ans = 64'h3FE02003FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1589031\n"); - end - xrf = 64'h4DC0007FFFFFBFFF; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h7FF1C24919B8C488; - ans = 64'h7FF9C24919B8C488; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1589645\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hC06FFBFFFFFFFFDF; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hC07FFBFFFFFFFFDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1590259\n"); - end - xrf = 64'h0C30001000001FFF; - y = 64'h3FDFFFFFFFFBFFFD; - zrf = 64'hC3E2000000003FFF; - ans = 64'hC3E2000000003FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1590873\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'hC01DFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1591487\n"); - end - xrf = 64'h39A00000FFFFFFF7; - y = 64'hC0200000FFFFFFFF; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1592101\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'hC2AA4072EAF00758; - ans = 64'hC2AA4072EAF01758; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1592715\n"); - end - xrf = 64'h37FD755CDABEA76D; - y = 64'h3C5FFFDBFFFFFFFF; - zrf = 64'hBFE0000000007FF8; - ans = 64'hBFE0000000007FF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1593329\n"); - end - xrf = 64'h801197F207B69AE6; - y = 64'hC010000000000001; - zrf = 64'h4000000000000000; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1593943\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h41EF00000000001F; - zrf = 64'h315FFFFFFFFFFFC0; - ans = 64'h41FF00000000001E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1594557\n"); - end - xrf = 64'hABBFFBFFFFFF0000; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hC1F748C9C20C8D0E; - ans = 64'hC1F748C9C20C8D0E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1595171\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h480FFFFFFFFFC07F; - zrf = 64'hBCA0000000000000; - ans = 64'h481FFFFFFFFFC07E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1595785\n"); - end - xrf = 64'h3FF0000000007FDF; - y = 64'h6E3FFFFFDFFFFFDF; - zrf = 64'h7FF1FEFFFFFFFFFF; - ans = 64'h7FF9FEFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1596399\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hC340000000000001; - zrf = 64'h3FD0000000000000; - ans = 64'hC350000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1597013\n"); - end - xrf = 64'hB800005FFFFFFFFF; - y = 64'hC18FFFFFFE0007FE; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1597627\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h3FE8DD2068625FC3; - ans = 64'hC35FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1598241\n"); - end - xrf = 64'hC035303BE73A8A2A; - y = 64'hB7FFFFFFDFFFBFFF; - zrf = 64'h43A6B1CE510FDDF7; - ans = 64'h43A6B1CE510FDDF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1598855\n"); - end - xrf = 64'hB21FFFFE0001FFFE; - y = 64'hFFE0000000000000; - zrf = 64'h3FF0000000000001; - ans = 64'h720FFFFE0001FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1599469\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hBFF00000000BFFFF; - zrf = 64'hBE90000000203FFE; - ans = 64'hC0000000200BFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1600083\n"); - end - xrf = 64'h43F0000EFFFFFFFF; - y = 64'hFFE0000000000001; - zrf = 64'h00218A882612E878; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1600697\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'h3F90000000083FFF; - zrf = 64'h8010000000000001; - ans = 64'h3FA0000000083FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1601311\n"); - end - xrf = 64'h49EE00FFFFFFFFFE; - y = 64'h60BFFFF7FFF00000; - zrf = 64'h401FFE0000000002; - ans = 64'h6ABE00F87FB0FF7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1601925\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hFFF0000000000000; - zrf = 64'h3CA0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1602539\n"); - end - xrf = 64'h3FF0001FFFFFFFFF; - y = 64'h37F1095A919815A3; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1603153\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hFFF0000000000001; - zrf = 64'hD282D5D3556E116C; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1603767\n"); - end - xrf = 64'h802FFFFFFFF001FF; - y = 64'h3F4FBFFFFFFFFFDF; - zrf = 64'hB81BE0B691B01D79; - ans = 64'hB81BE0B691B01D79; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1604381\n"); - end - xrf = 64'h41D0040000000000; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h3FEFFFFFFFFFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1604995\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hBC8FFF7FFFFFFFFF; - zrf = 64'h802C00000000007E; - ans = 64'hBC9FFF7FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1605609\n"); - end - xrf = 64'hB71A7857DD67746E; - y = 64'h0000000000000000; - zrf = 64'h380007F7FFFFFFFF; - ans = 64'h380007F7FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1606223\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h40541CECECF3BC00; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h40641CECECF3BBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1606837\n"); - end - xrf = 64'h0DFFFFFF00000008; - y = 64'hC7E000000008001F; - zrf = 64'h7FF6A62452074BC7; - ans = 64'h7FFEA62452074BC7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1607451\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h002FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1608065\n"); - end - xrf = 64'h800FFFF7FFFFBFFF; - y = 64'h407335261EC0BFB2; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1608679\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h0010000000000000; - zrf = 64'hD0B01FFFFFFFBFFF; - ans = 64'hD0B01FFFFFFFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1609293\n"); - end - xrf = 64'hBFDFFFC000000004; - y = 64'hC00000000003FFBF; - zrf = 64'hC53BFBFFFFFFFFFE; - ans = 64'hC53BFBFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1609907\n"); - end - xrf = 64'h43C483F6E8D46B6A; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1610521\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'hC3EFFFFE01FFFFFE; - zrf = 64'h40F73755595D1E7C; - ans = 64'hC3FFFFFE01FFFFE5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1611135\n"); - end - xrf = 64'h410FFFFF8000001E; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hC1FD1E0EB5DF203D; - ans = 64'hC1FD1E0EB5DF203D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1611749\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'hFFD53A3B1BD0418E; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1612363\n"); - end - xrf = 64'hC00FFFEFFFFFF7FE; - y = 64'hC3CFE001FFFFFFFE; - zrf = 64'h41C00003FFFFFF7F; - ans = 64'h43EFDFF21002F805; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1612977\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h3CBFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1613591\n"); - end - xrf = 64'h3FC0400040000000; - y = 64'hC0200000004001FE; - zrf = 64'hC010000000000000; - ans = 64'hC014100010104082; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1614205\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h47EEC35A3E8C408E; - ans = 64'h47EEC35A3E8C408E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1614819\n"); - end - xrf = 64'hB7CFFFFDFFFFFFBE; - y = 64'hE79FFFFFFBFFFF7E; - zrf = 64'hB7FFFFE000000400; - ans = 64'h5F7FFFFDFBFFFF7C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1615433\n"); - end - xrf = 64'h3D5DFFFE00000000; - y = 64'h3FD0000000000001; - zrf = 64'h3FD0000000000000; - ans = 64'h3FD0000000000780; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1616047\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'hC12FFEFFFFFFFFFE; - zrf = 64'hBFDC4312AA3B4103; - ans = 64'hC13FFF00710C4AA5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1616661\n"); - end - xrf = 64'h4020000000000207; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h3CB10000000003FE; - ans = 64'h4010000000000207; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1617275\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'hB7E00000000007BF; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1617889\n"); - end - xrf = 64'h43CFFFFEFFFFFE00; - y = 64'hC3E1DFFFFFFFFFFE; - zrf = 64'hC3DFDB4465B607F2; - ans = 64'hC7C1DFFF70FFFEE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1618503\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h3FE0000000000001; - zrf = 64'h0000000000000000; - ans = 64'h3FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1619117\n"); - end - xrf = 64'h43401FFFFFFFFFBF; - y = 64'hBFCFFBFFFFFFFE00; - zrf = 64'hC000000000000001; - ans = 64'hC3201DFBFFFFFEC1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1619731\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h41D0B0544FEB5078; - ans = 64'h41D0B054506B5078; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1620345\n"); - end - xrf = 64'h434FFFFFFFF8FFFF; - y = 64'h400FFFFC07FFFFFE; - zrf = 64'hC3D07FFFFBFFFFFF; - ans = 64'hC3D0400003F00DFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1620959\n"); - end - xrf = 64'hB7F0003FFFFFFFBF; - y = 64'h3FF0000000000000; - zrf = 64'h3CA0000000000001; - ans = 64'h3CA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1621573\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h401FFFFFFFBFEFFF; - zrf = 64'hBFBFFFFFFBFFFBFF; - ans = 64'h402FBFFFFFC7F005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1622187\n"); - end - xrf = 64'h3FD7C889A9DD25D9; - y = 64'h3FF0000000000001; - zrf = 64'hB7EFFF0001FFFFFE; - ans = 64'h3FD7C889A9DD25DA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1622801\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h37E38E855844BDB2; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1623415\n"); - end - xrf = 64'h3FBFFFFFFFFF8800; - y = 64'h404FFFFFBC000000; - zrf = 64'hC31FF80003FFFFFF; - ans = 64'hC31FF80003FFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1624029\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1624643\n"); - end - xrf = 64'hC3B00000FFFF7FFF; - y = 64'h0010000009FFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1625257\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h4000000000000001; - zrf = 64'hB80B4B5C90860317; - ans = 64'h4010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1625871\n"); - end - xrf = 64'h000C37F7A56E5695; - y = 64'h2A72123EDDA1B8F9; - zrf = 64'hB910080000040000; - ans = 64'hB910080000040000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1626485\n"); - end - xrf = 64'h434FFFFFFD000000; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h436FFFFFFCFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1627099\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h405FC00004000000; - zrf = 64'hC1E0000001FFFFFC; - ans = 64'hC1DFFFFFC47FFFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1627713\n"); - end - xrf = 64'hC1EFC00000004000; - y = 64'h4010000000000000; - zrf = 64'hCFC858BF316FDD04; - ans = 64'hCFC858BF316FDD04; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1628327\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h41EFFFFFFC3FFFFE; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h435000007FFFFFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1628941\n"); - end - xrf = 64'hC5002000000001FE; - y = 64'h002FFFFF0000001E; - zrf = 64'hBF20800000000000; - ans = 64'hBF20800000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1629555\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1630169\n"); - end - xrf = 64'h0010000000020800; - y = 64'hBFC13358D21972CF; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hBFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1630783\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h4340000000000000; - zrf = 64'h41D007FFFFFFF800; - ans = 64'h435000001007FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1631397\n"); - end - xrf = 64'h4760000020003FFF; - y = 64'hED03F987D1321ACA; - zrf = 64'h4940000001008000; - ans = 64'hF473F987F9257A51; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1632011\n"); - end - xrf = 64'hC3CFFDFFFFFFFF7F; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'hC72FFDFFFFFFFF7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1632625\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'hC7F001FFFFEFFFFF; - zrf = 64'hC1D0000000200FFF; - ans = 64'hC80001FFFFEFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1633239\n"); - end - xrf = 64'hC3FEDDFD05C7A4CA; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h401FFFFDF7FFFFFF; - ans = 64'hC75EDDFD05C7A4C8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1633853\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h8020007FFFFFBFFE; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h401FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1634467\n"); - end - xrf = 64'h4000002003FFFFFE; - y = 64'hBC4FFFFFBFFFFFFE; - zrf = 64'hBFBFFFFFFFFFE3FF; - ans = 64'hBFBFFFFFFFFFE400; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1635081\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h7FE0000000000001; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1635695\n"); - end - xrf = 64'hC6500004FFFFFFFE; - y = 64'h41DFFFC000008000; - zrf = 64'hBFE0000000000000; - ans = 64'hC83FFFC9FFEC7FFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1636309\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h7FFFFFFE000007FE; - ans = 64'h7FFFFFFE000007FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1636923\n"); - end - xrf = 64'h3FD0000000500000; - y = 64'h41C000001FFFDFFF; - zrf = 64'h40102011D91D9285; - ans = 64'h41A00000285FE8EC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1637537\n"); - end - xrf = 64'h43E000200FFFFFFF; - y = 64'h7FF0000000000001; - zrf = 64'h0000000000000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1638151\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h3596637D20B04D3A; - zrf = 64'hBF8106C2B0B30F67; - ans = 64'hBF8106C2B0B30F67; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1638765\n"); - end - xrf = 64'hBFF0000400007FFF; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h402FFFF000007FFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1639379\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h3CA351FEA32C59ED; - zrf = 64'h4010000000000000; - ans = 64'h4010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1639993\n"); - end - xrf = 64'hC03F7FFFFFFFFFE0; - y = 64'hC600000040400000; - zrf = 64'h9B87FF7FFFFFFFFF; - ans = 64'h464F80007E7DFFE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1640607\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h8000000000000000; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1641221\n"); - end - xrf = 64'h3DE0002000000080; - y = 64'hBFE9F6F80CF16503; - zrf = 64'hBFD0000000000001; - ans = 64'hBFD000000019F72D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1641835\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hC7F00000000005FE; - ans = 64'hC7F00000000005FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1642449\n"); - end - xrf = 64'hC00DFFF800000000; - y = 64'h401FDFFFFFFFFFFF; - zrf = 64'hC34B14F95370BE13; - ans = 64'hC34B14F95370BE22; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1643063\n"); - end - xrf = 64'hC011F773A1BF66A5; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1643677\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'hB7FA19DC3A5A0D78; - zrf = 64'h3FDF7EFFFFFFFFFF; - ans = 64'h3FDF7EFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1644291\n"); - end - xrf = 64'hB028000000000FFF; - y = 64'h8010000000000001; - zrf = 64'hBFFFFF0000080000; - ans = 64'hBFFFFF0000080000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1644905\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'hFFD0000400000003; - zrf = 64'h4000000000000001; - ans = 64'hFFE0000400000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1645519\n"); - end - xrf = 64'hC1D0000000408000; - y = 64'h4CC000003FFFFF00; - zrf = 64'hBFBF7FC4A718A597; - ans = 64'hCEA0000040407F01; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1646133\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'hC010000000000001; - ans = 64'hC010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1646747\n"); - end - xrf = 64'hC80FFF0000000002; - y = 64'hDF00FFFFDFFFFFFF; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h6720FF77E0010000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1647361\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'hBCA0000000000001; - zrf = 64'h3F8000000001FF00; - ans = 64'h3F8000000001FE80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1647975\n"); - end - xrf = 64'hC03B661E51E64B35; - y = 64'hBF0FFFFFFF7FFFEF; - zrf = 64'h41B7EF43DA372A52; - ans = 64'h41B7EF43DA3797EA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1648589\n"); - end - xrf = 64'h43CFFFFFFFFBFFFA; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1649203\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h572007FFFFFFFFEF; - zrf = 64'hC02C00B70D0083D1; - ans = 64'h573007FFFFFFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1649817\n"); - end - xrf = 64'hFFDFFFFFDBFFFFFF; - y = 64'hBFD0000000000000; - zrf = 64'h3CA0000020000008; - ans = 64'h7FBFFFFFDBFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1650431\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h3EB3A8C18215EEDE; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h400000013A8C1821; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1651045\n"); - end - xrf = 64'hAFBF4F812341AB31; - y = 64'h3F104001FFFFFFFF; - zrf = 64'h80114411054D7F17; - ans = 64'hAEDFCCC311BED644; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1651659\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC013FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1652273\n"); - end - xrf = 64'hC102BA21DE1A476C; - y = 64'hBECFFFFFF0000003; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h3FE2BA21D4BD367F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1652887\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'hBFE0000000000000; - zrf = 64'hF9CFFFFF3FFFFFFE; - ans = 64'hF9CFFFFF3FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1653501\n"); - end - xrf = 64'h393FFDFFFFFFF800; - y = 64'h004E11D80A9D5AFF; - zrf = 64'h41F00003FF7FFFFF; - ans = 64'h41F00003FF7FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1654115\n"); - end - xrf = 64'hC8000000000041FF; - y = 64'hBFE0000000000001; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'h47F0000000004200; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1654729\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h43DFFFFFFFFFDFBF; - zrf = 64'hB800000000007FFC; - ans = 64'h43EFFFFFFFFFDFBD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1655343\n"); - end - xrf = 64'h665FFFFFFFF7F000; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h41C000020001FFFE; - ans = 64'hE65FFFFFFFF7EFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1655957\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h401077A5A2BE365A; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h402277A5A2BE3659; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1656571\n"); - end - xrf = 64'h061FFFFFC1FFFFFF; - y = 64'hC070000040000400; - zrf = 64'hBFBF810000000000; - ans = 64'hBFBF810000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1657185\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; + x = 64'h3FF0000000000001; y = 64'hBFF0000000000001; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1657799\n"); - end - xrf = 64'h7FF6BBA8EE66553A; - y = 64'hD2200000017FFFFE; - zrf = 64'h8010000000000000; - ans = 64'h7FFEBBA8EE66553A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1658413\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hBFE00400000FFFFE; - ans = 64'hC01200800001FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1659027\n"); - end - xrf = 64'h7FDA73B4F67E128A; - y = 64'h7FF1FFFFFFFFFFFD; - zrf = 64'hCABF7FF800000000; - ans = 64'h7FF9FFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1659641\n"); - end - xrf = 64'hAF60000009FFFFFE; - y = 64'hC000000000000000; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1660255\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h3FC7DE7FE710E06E; - zrf = 64'h3FFBFFFEFFFFFFFE; - ans = 64'h4000FBCF7CE21C0D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1660869\n"); - end - xrf = 64'hC04FFFFFFFC00007; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'hC1E000000FFFFF80; - ans = 64'hC1DFFFFFDFFFFF00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1661483\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h3FCC000010000000; - zrf = 64'h3FE0000000000000; - ans = 64'h3FEE000007FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1662097\n"); - end - xrf = 64'hC3F2E37F64E0E0B4; - y = 64'hB96F00000FFFFFFE; - zrf = 64'hC1DFE00400000000; - ans = 64'hC1DFE00400000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1662711\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'hC010000000000000; - zrf = 64'hBFF0000000000000; - ans = 64'hC021FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1663325\n"); - end - xrf = 64'hB7BFDFFFFFFF0000; - y = 64'hA7FF7FFEFFFFFFFE; - zrf = 64'h8000000000000001; - ans = 64'h1FCF607F00FF03FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1663939\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hEC562C4E9A8A0F85; - ans = 64'hEC562C4E9A8A0F85; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1664553\n"); - end - xrf = 64'hBDB000000FFFFC00; - y = 64'h402A95C63B51BA70; - zrf = 64'hB816D59A68BD29ED; - ans = 64'hBDEA95C655E77A06; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1665167\n"); - end - xrf = 64'hC1C2DEC562387EB0; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hC010000000000001; - ans = 64'h41F2DEC561F87EAF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1665781\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'hBCAFF0000007FFFE; - zrf = 64'h403FBFFFFFBFFFFF; - ans = 64'h403FBFFFFFBFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1666395\n"); - end - xrf = 64'hC1BFDFF7FFFFFFFF; - y = 64'hC340000000000001; - zrf = 64'hFFD20668823AB724; - ans = 64'hFFD20668823AB724; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1667009\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h45F7FFC000000000; - zrf = 64'h3FD0000000000001; - ans = 64'h4607FFBFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1667623\n"); - end - xrf = 64'hC340000000107FFF; - y = 64'h40DD42F951360FAA; - zrf = 64'h40FFFFDFFFFFFFFB; - ans = 64'hC42D42F951543CB5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1668237\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hBFE0000000000001; - ans = 64'hC35FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1668851\n"); - end - xrf = 64'hBFDFF02000000000; - y = 64'hC3EFFFFFFFFFFB7F; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1669465\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'hFFE0000000000001; - zrf = 64'hC020088000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1670079\n"); - end - xrf = 64'hC7EFFFFFE00003FF; - y = 64'hC1F1FFF7FFFFFFFE; - zrf = 64'h3CBE81B9C620397C; - ans = 64'h49F1FFF7EE000A3D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1670693\n"); - end - xrf = 64'hC342F1C3ADA6D99F; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1671307\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h3C8FE1FFFFFFFFFF; - zrf = 64'h39C07FEFFFFFFFFF; - ans = 64'h3C9FE20000000081; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1671921\n"); - end - xrf = 64'hA2345AA3A1084924; - y = 64'hFFF0000000000000; - zrf = 64'hB8104000FFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1672535\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'h41CBFFFFFFFFE000; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h41DBFFFFFFFFDFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1673149\n"); - end - xrf = 64'hB96FFFFFFFFFF77E; - y = 64'h49AFFFBFFFFE0000; - zrf = 64'h5CDF7FEFFFFFFFFF; - ans = 64'h5CDF7FEFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1673763\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFE; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1674377\n"); - end - xrf = 64'h400FFFC0000FFFFE; - y = 64'h802FE000001FFFFF; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1674991\n"); - end - xrf = 64'h4000000000000000; - y = 64'h0000000000000000; - zrf = 64'h001000FFFFFC0000; - ans = 64'h001000FFFFFC0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1675605\n"); - end - xrf = 64'h37E743D23F8C0702; - y = 64'h407042B6B14E36BF; - zrf = 64'hB3EFFFFFF7FFFFBF; - ans = 64'h3867A4D3A819BB92; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1676219\n"); - end - xrf = 64'h524001FF00000000; - y = 64'h0000000000000001; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hBFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1676833\n"); - end - xrf = 64'h4000000000000000; - y = 64'h4F02493E952EEE02; - zrf = 64'h0A9F0000FFFFFFFF; - ans = 64'h4F12493E952EEE02; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1677447\n"); - end - xrf = 64'hBFD3DB57D4E982A8; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h801FF80000007FFF; - ans = 64'h8022776AFA9D7054; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1678061\n"); - end - xrf = 64'h4000000000000000; - y = 64'h0AEFF00000040000; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h0AFFF00000040000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1678675\n"); - end - xrf = 64'h37EFFFFFFFC03FFF; - y = 64'h41E000003FFC0000; - zrf = 64'hC3DFFF0000000100; - ans = 64'hC3DFFF0000000100; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1679289\n"); - end - xrf = 64'h4000000000000000; - y = 64'h0010000000000001; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hBCAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1679903\n"); - end - xrf = 64'h41EB000000000000; - y = 64'h4063494AAD05F0DE; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1680517\n"); - end - xrf = 64'h4000000000000000; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h41EFFFFF00007FFF; - ans = 64'h41EFFFFF00007FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1681131\n"); - end - xrf = 64'hC341FFFFFFFDFFFF; - y = 64'h002FFFFFFF7FBFFF; - zrf = 64'hC03112A588EFBE99; - ans = 64'hC03112A588EFBE99; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1681745\n"); - end - xrf = 64'h001C0C4BE24F40FD; - y = 64'h3CA0000000000000; - zrf = 64'hBFF0000000000000; - ans = 64'hBFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1682359\n"); - end - xrf = 64'h4000000000000000; - y = 64'h3FF524055197547C; - zrf = 64'hBF1EB55F1B5292BA; - ans = 64'h400523C7E6D91DD7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1682973\n"); - end - xrf = 64'hC0D50A2D635E365F; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h41F6244AC1402982; - ans = 64'h41F6244AC1402982; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1683587\n"); - end - xrf = 64'h4000000000000000; - y = 64'h3FE0000007C00000; - zrf = 64'h0010000000000000; - ans = 64'h3FF0000007C00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1684201\n"); - end - xrf = 64'hB80FE000001FFFFE; - y = 64'hBFF00000107FFFFF; - zrf = 64'h405000040000000F; - ans = 64'h405000040000000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1684815\n"); - end - xrf = 64'h4000000000000000; - y = 64'h3FD0000000000000; - zrf = 64'hBCA0000000000000; - ans = 64'h3FDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1685429\n"); - end - xrf = 64'hBFDFFBFFFFFBFFFF; - y = 64'h480FFDFFFFFFFF00; - zrf = 64'h4340000000000001; - ans = 64'hC7FFFA003FFBFF3F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1686043\n"); - end - xrf = 64'h4000000000000000; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h000F6C9C104B7ABB; - ans = 64'h3FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1686657\n"); - end - xrf = 64'hC02FFFFFFF080000; - y = 64'h43EAECF0AEF79302; - zrf = 64'hFFDFFFFFF00001FF; - ans = 64'hFFDFFFFFF00001FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1687271\n"); - end - xrf = 64'h3CA00FFDFFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1687885\n"); - end - xrf = 64'h4000000000000000; - y = 64'h0001B09F750C484A; - zrf = 64'hBFCFF80001FFFFFF; - ans = 64'hBFCFF80001FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1688499\n"); - end - xrf = 64'h403FF80001FFFFFF; - y = 64'h3FE0000000000001; - zrf = 64'h41CFFFEFFFFFE000; - ans = 64'h41CFFFF007FDE001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1689113\n"); - end - xrf = 64'h4000000000000000; - y = 64'h425EFFFFFFFFFFBF; - zrf = 64'h0000000000000001; - ans = 64'h426EFFFFFFFFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1689727\n"); - end - xrf = 64'h43F2000000000100; - y = 64'hC0AFBFFFFFFFFFFE; - zrf = 64'hC01FE0000007FFFF; - ans = 64'hC4B1DC00000000FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1690341\n"); - end - xrf = 64'h4000000000000000; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h8010000000000001; - ans = 64'h3FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1690955\n"); - end - xrf = 64'hC020003FF7FFFFFF; - y = 64'hC7E803FFFFFFFFFE; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h4818046003FDFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1691569\n"); - end - xrf = 64'h4000000000000000; - y = 64'h3FF0000000000001; - zrf = 64'hC028C4AD1E629470; - ans = 64'hC024C4AD1E629470; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1692183\n"); - end - xrf = 64'h41EFF80000010000; - y = 64'h41FFFFFFC000FFFE; - zrf = 64'hB81FFFFF03FFFFFE; - ans = 64'h43FFF7FFC011FFBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1692797\n"); - end - xrf = 64'h7FDE000000000FFE; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'h7FEE000000000FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1693411\n"); - end - xrf = 64'h4000000000000000; - y = 64'h466FFFFF77FFFFFE; - zrf = 64'h41F0000040200000; - ans = 64'h467FFFFF77FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1694025\n"); - end - xrf = 64'hC1CFFFFDDFFFFFFF; - y = 64'h4000000000000000; - zrf = 64'hBEBA2BDB90324F31; - ans = 64'hC1DFFFFDE0000006; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1694639\n"); - end - xrf = 64'h4000000000000000; - y = 64'h37E0000000008FFF; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1695253\n"); - end - xrf = 64'h43D0000008000FFE; - y = 64'hB81FFFFF7FFFFF80; - zrf = 64'hC3E0007FFFFFBFFE; - ans = 64'hC3E0007FFFFFBFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1695867\n"); - end - xrf = 64'h4000000000000000; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h401FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1696481\n"); - end - xrf = 64'hC281963398C5F833; - y = 64'hC3C0000100000003; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h46519634B22931C3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1697095\n"); - end - xrf = 64'h4000000000000000; - y = 64'h4010000000000000; - zrf = 64'hBAFFFFC000000010; - ans = 64'h4020000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1697709\n"); - end - xrf = 64'h400F800001FFFFFE; - y = 64'hBCA0000000000090; - zrf = 64'h53400000801FFFFF; - ans = 64'h53400000801FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1698323\n"); - end - xrf = 64'h35E0004003FFFFFE; - y = 64'h4010000000000001; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hBCAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1698937\n"); - end - xrf = 64'h4000000000000000; - y = 64'h37FFFFFBFFDFFFFE; - zrf = 64'hBFB9F6ED561680FF; - ans = 64'hBFB9F6ED561680FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1699551\n"); - end - xrf = 64'h7FD00000003DFFFF; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hBFD0FFFFFFFFFEFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1700165\n"); - end - xrf = 64'h4000000000000000; - y = 64'hBFB000FFFFFFFFC0; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1700779\n"); - end - xrf = 64'hFFE000000008000E; - y = 64'h41F00000201FFFFF; - zrf = 64'h4730007800000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1701393\n"); - end - xrf = 64'h4000000000000000; - y = 64'h4340000000000001; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1702007\n"); - end - xrf = 64'hCE41BA3F359D9A50; - y = 64'hC00E3FFFFFFFFFFF; - zrf = 64'h4000000000000000; - ans = 64'h4E60C20FC0AEFBDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1702621\n"); - end - xrf = 64'h4000000000000000; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hBFCFF8000000003E; - ans = 64'h435FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1703235\n"); - end - xrf = 64'hC345C210B27A7C55; - y = 64'hD04FFDFFFFFFFC00; - zrf = 64'hBFE7FFFE00000000; - ans = 64'h53A5C0B4916F51F5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1703849\n"); - end - xrf = 64'h7FD0000000001FFB; - y = 64'h7FE0000000000000; - zrf = 64'hBCA0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1704463\n"); - end - xrf = 64'h4000000000000000; - y = 64'hC0001FFFFFFFFFDF; - zrf = 64'h3E3000007FFFF7FF; - ans = 64'hC0101FFFFFBFFFDD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1705077\n"); - end - xrf = 64'h37FB660C620F438B; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h436FFFFFF7FFFBFF; - ans = 64'h77FB660C620F438A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1705691\n"); - end - xrf = 64'h4000000000000000; - y = 64'hBE9E5650DF91EE0C; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1706305\n"); - end - xrf = 64'hC7E0008080000000; - y = 64'hC629AB6B7F281634; - zrf = 64'h001001FF7FFFFFFF; - ans = 64'h4E19AC39A7DF6B6E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1706919\n"); - end - xrf = 64'h4000000000000000; - y = 64'h7FF0000000000000; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1707533\n"); - end - xrf = 64'h3FCDD2DC2964A124; - y = 64'h43D0000038000000; - zrf = 64'h3FF0000000000001; - ans = 64'h43ADD2DC91C6A3B5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1708147\n"); - end - xrf = 64'h4000000000000000; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h4C2FFFFF7FFFFFBF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1708761\n"); - end - xrf = 64'hE3E00FFFFFFC0000; - y = 64'hC3D000000000005E; - zrf = 64'h4A4D8898DFF8B465; - ans = 64'h67C00FFFFFFC005E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1709375\n"); - end - xrf = 64'h001000080001FFFE; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h8010000000000001; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1709989\n"); - end - xrf = 64'h4000000000000000; - y = 64'h3FF00000107FFFFF; - zrf = 64'hC03FEFFFFE000000; - ans = 64'hC03DEFFFFBF00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1710603\n"); - end - xrf = 64'h47FF17EBE05658B2; - y = 64'h8000000000000001; - zrf = 64'h6C2FFFFFFFFFF5FE; - ans = 64'h6C2FFFFFFFFFF5FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1711217\n"); - end - xrf = 64'h4000000000000000; - y = 64'hC2AFFFFFFFFFFCFE; - zrf = 64'hC340000000000001; - ans = 64'hC3400FFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1711831\n"); - end - xrf = 64'h3204CCAB7A4D2D0C; - y = 64'hBC01FFFFFFFFFDFE; - zrf = 64'hFFEF7FFFFFF7FFFF; - ans = 64'hFFEF7FFFFFF7FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1712445\n"); - end - xrf = 64'h4000000000000000; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1713059\n"); - end - xrf = 64'hBFF000007DFFFFFF; - y = 64'hBFE89D55BBC01104; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FFC4EAB3ECB8A14; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1713673\n"); - end - xrf = 64'h4000000000000000; - y = 64'h8010000000000000; - zrf = 64'h380FFF00000001FF; - ans = 64'h380FFF00000001FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1714287\n"); - end - xrf = 64'hB9B000080000003F; - y = 64'hB93FFFFFFFFE0001; - zrf = 64'hBFD1698896277BD3; - ans = 64'hBFD1698896277BD3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1714901\n"); - end - xrf = 64'h400FEFE000000000; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h8041F7EFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1715515\n"); - end - xrf = 64'h4000000000000000; - y = 64'h40D00000000FFF7E; - zrf = 64'h40000000003FDFFF; - ans = 64'h40E000400010007D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1716129\n"); - end - xrf = 64'hC723258BFDA071ED; - y = 64'hBCA0000000000000; - zrf = 64'h3FB0000000200001; - ans = 64'h43D3258BFDA071ED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1716743\n"); - end - xrf = 64'h4000000000000000; - y = 64'h80200101FFFFFFFE; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1717357\n"); - end - xrf = 64'h41E0000DFFFFFFFF; - y = 64'h412000000000801E; - zrf = 64'hBFAFFFFFFFFE0007; - ans = 64'h4310000E0000801D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1717971\n"); - end - xrf = 64'h4000000000000000; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1718585\n"); - end - xrf = 64'hFFEFFFFFFFFFF7FE; - y = 64'h47F000000003FFFF; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1719199\n"); - end - xrf = 64'h4000000000000000; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hB16000003FFFFFFF; - ans = 64'hBCBFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1719813\n"); - end - xrf = 64'h43C53AE0E828B89B; - y = 64'hB8D2000000010000; - zrf = 64'h400FEFFFFFFFFFFD; - ans = 64'h400FEFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1720427\n"); - end - xrf = 64'h016BFFFFFFFFBFFF; - y = 64'hBFD0000000000001; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1721041\n"); - end - xrf = 64'h4000000000000000; - y = 64'h47E001FFFF800000; - zrf = 64'h480420C387510B53; - ans = 64'h480C21C387110B53; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1721655\n"); - end - xrf = 64'hC3C087FFFFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'hC02FFFFFFFFFFFF2; - ans = 64'h43B087FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1722269\n"); - end - xrf = 64'h4000000000000000; - y = 64'h7FE0000037FFFFFE; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1722883\n"); - end - xrf = 64'hC1DFFFFEFFFF7FFE; - y = 64'h402FFFFFDEFFFFFF; - zrf = 64'h4F515204563A7F36; - ans = 64'h4F515204563A7F36; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1723497\n"); - end - xrf = 64'h4000000000000000; - y = 64'hBFE0000000000001; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h401BFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1724111\n"); - end - xrf = 64'h40100200000007FF; - y = 64'h47EFF7FFFFFFFFF0; - zrf = 64'h3FD0000000000000; - ans = 64'h480FFBFF00000FEA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1724725\n"); - end - xrf = 64'h4000000000000000; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h401FFFFFFF880000; - ans = 64'h4017FFFFFF880000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1725339\n"); - end - xrf = 64'hB806261012190A5F; - y = 64'hC343FFFFFFFFFFDE; - zrf = 64'h402830644E65DDF0; - ans = 64'h402830644E65DDF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1725953\n"); - end - xrf = 64'h47F927AEB72E590C; - y = 64'hBFF0000000000000; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1726567\n"); - end - xrf = 64'h4000000000000000; - y = 64'h755EA63AFBFA49E3; - zrf = 64'h6FBFFFE000000000; - ans = 64'h756EA63AFBFA49E3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1727181\n"); - end - xrf = 64'hC1DFFFFFFC000800; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h8151008000000000; - ans = 64'h41EFFFFFFC0007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1727795\n"); - end - xrf = 64'h4000000000000000; - y = 64'hBFE00000FFBFFFFE; - zrf = 64'hC000000000000000; - ans = 64'hC00800007FDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1728409\n"); - end - xrf = 64'hC4E00000004007FF; - y = 64'hB7E400000000007F; - zrf = 64'h37E0000000040002; - ans = 64'h3CD4000000500A7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1729023\n"); - end - xrf = 64'h4000000000000000; - y = 64'hC000000000000000; - zrf = 64'h4010000000000000; - ans = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1729637\n"); - end - xrf = 64'h47F9AFC4E5492F7B; - y = 64'h409E22E8C3182C5E; - zrf = 64'h3CA0000000000001; - ans = 64'h48A830CE2F1637DE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1730251\n"); - end - xrf = 64'h4000000000000000; - y = 64'hC000000000000001; - zrf = 64'hBF6FFFFF5FFFFFFF; - ans = 64'hC01003FFFFEC0001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1730865\n"); - end - xrf = 64'h4030000002000000; - y = 64'hC25FFFDFFFFFFFFF; - zrf = 64'hC0040000001FFFFF; - ans = 64'hC29FFFE0040005FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1731479\n"); - end - xrf = 64'h4010000400000006; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1732093\n"); - end - xrf = 64'h4000000000000000; - y = 64'h43F0FFFFFEFFFFFF; - zrf = 64'h3FBFFFFE00000002; - ans = 64'h4400FFFFFEFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1732707\n"); - end - xrf = 64'h40300146660A8F48; - y = 64'hC010000000000000; - zrf = 64'hBFC00FFFFFFFF800; - ans = 64'hC050094E660A8F44; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1733321\n"); - end - xrf = 64'h4000000000000000; - y = 64'h25F0DFEF7CAE8B52; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1733935\n"); - end - xrf = 64'hC3F0800003FFFFFF; - y = 64'h40F00000001EFFFF; - zrf = 64'hC18FFFFFFFFDEFFF; - ans = 64'hC4F08000041FF7FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1734549\n"); - end - xrf = 64'h4000000000000000; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h4000000000000001; - ans = 64'hC02BFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1735163\n"); - end - xrf = 64'hC37FFFFFFFF3FFFF; - y = 64'h401FFFFFFFFFF600; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'hC3AFFFFFFFF3F5FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1735777\n"); - end - xrf = 64'h4000000000000000; - y = 64'hC340000000000000; - zrf = 64'h4031000008000000; - ans = 64'hC34FFFFFFFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1736391\n"); - end - xrf = 64'hBFBFFFFF8000FFFF; - y = 64'h404000004000000F; - zrf = 64'h3C1FC1FFFFFFFFFE; - ans = 64'hC010000000007F0F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1737005\n"); - end - xrf = 64'h7CCFFFFFFFFFFFFE; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1737619\n"); - end - xrf = 64'h4000000000000000; - y = 64'h2ADFC00004000000; - zrf = 64'hB16FFFFFE00FFFFF; - ans = 64'hB16FFFFFE00FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1738233\n"); - end - xrf = 64'hC3DF7FFBFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hBFC0DB4FA7E69FC7; - ans = 64'h473F7FFBFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1738847\n"); - end - xrf = 64'h4000000000000000; - y = 64'hC1FFFFFDFFFFFFFE; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hC20FFFFE0007FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1739461\n"); - end - xrf = 64'h3F0077FFFFFFFFFF; - y = 64'h3FCC000000020000; - zrf = 64'h43DF1D64DBAB2499; - ans = 64'h43DF1D64DBAB2499; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1740075\n"); - end - xrf = 64'h4000000000000000; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1740689\n"); - end - xrf = 64'h41F400000001FFFE; - y = 64'h40800FFFFEFFFFFF; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h428413FFFEC201FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1741303\n"); - end - xrf = 64'h4000000000000000; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'hC06FFFFDFFFFFE00; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1741917\n"); - end - xrf = 64'h3F70000F7FFFFFFE; - y = 64'h40FE955D3D060580; - zrf = 64'h3FD0FFFFFDFFFFFE; - ans = 64'h407E99BADDB7D89A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1742531\n"); - end - xrf = 64'hC7E0FFFFE0000000; - y = 64'hFFF0000000000001; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1743145\n"); - end - xrf = 64'h4000000000000000; - y = 64'hC3FF3DB5443DB0CB; - zrf = 64'h43ECD85389B5C822; - ans = 64'hC40807A061D03EC2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1743759\n"); - end - xrf = 64'hC7FFFFFFF0001FFE; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h0000006FFFFFFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1744373\n"); - end - xrf = 64'h4000000000000000; - y = 64'h5851433A0C36872F; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'h5861433A0C36872F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1744987\n"); - end - xrf = 64'hC09FF7BFFFFFFFFF; - y = 64'h3800000000000FC0; - zrf = 64'hBE7000000000000E; - ans = 64'hBE7000000000000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1745601\n"); - end - xrf = 64'h4000000000000001; - y = 64'h0000000000000001; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h3FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1746215\n"); - end - xrf = 64'hFFD9F43EFD1ADAF1; - y = 64'h3FF4CC80FA5A7FC4; - zrf = 64'h0000000000000000; - ans = 64'hFFE0DE850BC7DB21; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1746829\n"); - end - xrf = 64'h4000000000000001; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'hC18FFFFFFFCFFFFE; - ans = 64'hC18FFFFFFFCFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1747443\n"); - end - xrf = 64'hC51F224DF686F6E9; - y = 64'hBF77FFFFFFFFFBFF; - zrf = 64'h3811FFFFFFFFEFFF; - ans = 64'h44A759BA78E53549; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1748057\n"); - end - xrf = 64'hC800000000007FFB; - y = 64'h0010000000000000; - zrf = 64'h4010000000000000; - ans = 64'h4010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1748671\n"); - end - xrf = 64'h4000000000000001; - y = 64'h38900000000FFFBF; - zrf = 64'h331583B66DB45ACA; - ans = 64'h38A00000000FFFC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1749285\n"); - end - xrf = 64'hC00FFFFFFC002000; - y = 64'h0010000000000001; - zrf = 64'h813DEEFF25B99912; - ans = 64'h813DEF0F25B99712; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1749899\n"); - end - xrf = 64'h4000000000000001; - y = 64'h400000000100007F; - zrf = 64'hBFD0000000000000; - ans = 64'h400E000002000100; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1750513\n"); - end - xrf = 64'hC7E0FFFFFF7FFFFF; - y = 64'h3F89E348A0C8D43A; - zrf = 64'h801FB486830D7FB5; - ans = 64'hC77B817D2A064737; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1751127\n"); - end - xrf = 64'h4000000000000001; - y = 64'h3CA0000000000000; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE0000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1751741\n"); - end - xrf = 64'h436D6341228748EE; - y = 64'h242000000FFFBFFF; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1752355\n"); - end - xrf = 64'h4000000000000001; - y = 64'h3CA0000000000001; - zrf = 64'h43D0000000004400; - ans = 64'h43D0000000004400; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1752969\n"); - end - xrf = 64'h801FFFFFBF000000; - y = 64'h4012B6DA70C3DECC; - zrf = 64'h0000000000000006; - ans = 64'h8042B6DA4AC07316; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1753583\n"); - end - xrf = 64'hBFDF803FFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h4000000000000001; - ans = 64'h4000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1754197\n"); - end - xrf = 64'h4000000000000001; - y = 64'h358FFFFFEFFFFFFE; - zrf = 64'hBF8FFFFFFFFFFFFE; - ans = 64'hBF8FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1754811\n"); - end - xrf = 64'hBFCFFEFFFFFFF7FE; - y = 64'h3FD0000000000000; - zrf = 64'h3FDFFFFFFFFF77FF; - ans = 64'h3FDC001FFFFF78FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1755425\n"); - end - xrf = 64'h4000000000000001; - y = 64'h3FCFFFFFFFFC01FF; - zrf = 64'hBCA0000000000001; - ans = 64'h3FDFFFFFFFFC01FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1756039\n"); - end - xrf = 64'h37F0000000801FFF; - y = 64'h37EFFFFFF001FFFF; - zrf = 64'h800FFFFFC0FFFFFE; - ans = 64'h2FEFFFFFF1023FFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1756653\n"); - end - xrf = 64'h4000000000000001; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h3FD0000000000001; - ans = 64'h3FF4000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1757267\n"); - end - xrf = 64'h43D0000004800000; - y = 64'hB91FFBFFFFFFFEFE; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1757881\n"); - end - xrf = 64'h4000000000000001; - y = 64'h3FE0000000000000; - zrf = 64'hC3D000000077FFFF; - ans = 64'hC3D000000077FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1758495\n"); - end - xrf = 64'h3FB00000040003FF; - y = 64'h3FD0000020800000; - zrf = 64'h3FEFF7FFFFEFFFFF; - ans = 64'h3FF03C00008A0010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1759109\n"); - end - xrf = 64'hAB0FFFFFF0100000; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1759723\n"); - end - xrf = 64'h4000000000000001; - y = 64'hC1C5B002CE2BD351; - zrf = 64'hB80337F20C2B93AE; - ans = 64'hC1D5B002CE2BD352; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1760337\n"); - end - xrf = 64'h4800000400400000; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'hC3CBC6C815066223; - ans = 64'h48000004003FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1760951\n"); - end - xrf = 64'h4000000000000001; - y = 64'hBFDFFF7FFFFFFFFD; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'hBFEFFF7FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1761565\n"); - end - xrf = 64'h400F9D7BCAC61F20; - y = 64'h47FF0000001FFFFF; - zrf = 64'hC00D1C5E24468EF4; - ans = 64'h481EA08FEC8F8BA2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1762179\n"); - end - xrf = 64'h4000000000000001; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h4010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1762793\n"); - end - xrf = 64'h3FF01FFFFFFFFF7F; - y = 64'h400FFFFFFFFEFFFC; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1763407\n"); - end - xrf = 64'h4000000000000001; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h4030000010000400; - ans = 64'h4034000010000400; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1764021\n"); - end - xrf = 64'h8000000000000407; - y = 64'hBFDFFFFFFFFFFEE0; - zrf = 64'hBFBF0000000FFFFF; - ans = 64'hBFBF0000000FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1764635\n"); - end - xrf = 64'h544A3DA4E3B766A1; - y = 64'h4000000000000001; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h545A3DA4E3B766A3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1765249\n"); - end - xrf = 64'h4000000000000001; - y = 64'h46CAC970B49DD3AD; - zrf = 64'hC0AFFFFFFFFFE00F; - ans = 64'h46DAC970B49DD3AF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1765863\n"); - end - xrf = 64'h8000000000020000; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h41FFFFFFFC00FFFF; - ans = 64'h41FFFFFFFC00FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1766477\n"); - end - xrf = 64'h4000000000000001; - y = 64'hB7EFFFE001FFFFFF; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hB7FFFFE002000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1767091\n"); - end - xrf = 64'hC00FFFFC0000001F; - y = 64'h7FF00FFFFFFFBFFF; - zrf = 64'hC08FFF7FFFFFFFFA; - ans = 64'h7FF80FFFFFFFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1767705\n"); - end - xrf = 64'h4000000000000001; - y = 64'h4010000000000001; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h4020000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1768319\n"); - end - xrf = 64'h37F1FFFFFFFFBFFF; - y = 64'h15EFFFFF9FFFFFFF; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1768933\n"); - end - xrf = 64'h4000000000000001; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hBFF1000010000000; - ans = 64'h402DDFFFFE000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1769547\n"); - end - xrf = 64'h75FFFFFF80007FFE; - y = 64'hC01FFFE000008000; - zrf = 64'h41F3FFFFFFFFEFFF; - ans = 64'hF62FFFDF80017FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1770161\n"); - end - xrf = 64'hB7EFFFC00000FFFF; - y = 64'h4340000000000000; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1770775\n"); - end - xrf = 64'h4000000000000001; - y = 64'hC00FF00000008000; - zrf = 64'h4010000001000000; - ans = 64'hC00FDFFFFE010004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1771389\n"); - end - xrf = 64'h7FF237D206D36360; - y = 64'h4340000000000001; - zrf = 64'hC3C7716C2259F813; - ans = 64'h7FFA37D206D36360; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1772003\n"); - end - xrf = 64'h4000000000000001; - y = 64'hC3C0FFDFFFFFFFFF; - zrf = 64'h8000000000000000; - ans = 64'hC3D0FFE000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1772617\n"); - end - xrf = 64'h414A3DD5DE82898B; - y = 64'h402F7EFFFFFFFFFE; - zrf = 64'h3CAFFEC000000000; - ans = 64'h4189D40C98598B4F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1773231\n"); - end - xrf = 64'h4000000000000001; - y = 64'h7FE0000000000000; - zrf = 64'h0010000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1773845\n"); - end - xrf = 64'h3FD20000FFFFFFFF; - y = 64'hBEE000000000F7FE; - zrf = 64'hC010000000000001; - ans = 64'hC010000090000801; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1774459\n"); - end - xrf = 64'h4000000000000001; - y = 64'h7FE0000000000001; - zrf = 64'h10D0000008000080; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1775073\n"); - end - xrf = 64'h3E5FFF7FFFFFFFDE; - y = 64'h40AFFFFEFE000000; - zrf = 64'hBFD000000000000B; - ans = 64'hBFCFFC0010203F95; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1775687\n"); - end - xrf = 64'hBFE050C5935F9B62; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h3FD0000000000001; - ans = 64'hFFE050C5935F9B61; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1776301\n"); - end - xrf = 64'h4000000000000001; - y = 64'h47FFFFFFFF7FFFEF; - zrf = 64'h6FF001FFFFFFFFFA; - ans = 64'h6FF001FFFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1776915\n"); - end - xrf = 64'hD7400007FFFFFFF7; - y = 64'h7FF0000000000000; - zrf = 64'h46200000017FFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1777529\n"); - end - xrf = 64'h4000000000000001; - y = 64'h402FFFFFFFFFFFD0; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1778143\n"); - end - xrf = 64'h3FBFFFF7FFFFFFFA; - y = 64'hBF8FFFFF3FFFFFFF; - zrf = 64'hC34800000000001F; - ans = 64'hC34800000000001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1778757\n"); - end - xrf = 64'h4000000000000001; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h0000000000000001; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1779371\n"); - end - xrf = 64'hC34FFFEFFFFFF7FE; - y = 64'hC000000000808000; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'h435FFFF00100F77C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1779985\n"); - end - xrf = 64'h4000000000000001; - y = 64'h8000000000000000; - zrf = 64'hBFEF62D1FFBD4AF4; - ans = 64'hBFEF62D1FFBD4AF4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1780599\n"); - end - xrf = 64'h43F64D8FB8BB1136; - y = 64'hC49E1FFFFFFFFFFF; - zrf = 64'hC8000002003FFFFF; - ans = 64'hC8A503044D682B33; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1781213\n"); - end - xrf = 64'hC0F0000000000407; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1781827\n"); - end - xrf = 64'h4000000000000001; - y = 64'hC02744F10D0CD258; - zrf = 64'h80276B5120A17EE2; - ans = 64'hC03744F10D0CD259; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1782441\n"); - end - xrf = 64'hBFF0002000000000; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h415FFFFFE0000010; - ans = 64'h415FFFFFE0000010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1783055\n"); - end - xrf = 64'h4000000000000001; - y = 64'hC022000080000000; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1783669\n"); - end - xrf = 64'hC02FFFF800000006; - y = 64'h40C0000010000FFF; - zrf = 64'hC01FFFFF8003FFFF; - ans = 64'hC100003C0FFF0C0A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1784283\n"); - end - xrf = 64'h4000000000000001; - y = 64'h8010000000000001; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1784897\n"); - end - xrf = 64'hB7F800B345BCBFC9; - y = 64'h7FE9C88F81D7641E; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hF7F356FC1374D3A5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1785511\n"); - end - xrf = 64'h4000000000000001; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h40A001FFFE000000; - ans = 64'h40A001FFFE000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1786125\n"); - end - xrf = 64'h3810010400000000; - y = 64'h800A307BC417CC79; - zrf = 64'h412D6D16F2C3A035; - ans = 64'h412D6D16F2C3A035; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1786739\n"); - end - xrf = 64'hBFE01003FFFFFFFF; - y = 64'hBCA0000000000001; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h3C90100400000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1787353\n"); - end - xrf = 64'h4000000000000001; - y = 64'hC3C000000001FF7F; - zrf = 64'h442FFFFF00000FFF; - ans = 64'h442F7FFF00000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1787967\n"); - end - xrf = 64'hC3E0000007FDFFFE; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'hD8896E54EF85B595; - ans = 64'hD8896E54EF85B595; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1788581\n"); - end - xrf = 64'h4000000000000001; - y = 64'hBFC4000000004000; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1789195\n"); - end - xrf = 64'h801003FFFFFFFFFB; - y = 64'hC02FFBFF00000000; - zrf = 64'hBC64A4C6EF2A4F02; - ans = 64'hBC64A4C6EF2A4F02; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1789809\n"); - end - xrf = 64'h4000000000000001; - y = 64'hBFD0000000000000; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1790423\n"); - end - xrf = 64'h3FC2D2609C21B45C; - y = 64'h41DFFFFFFFC0FFFE; - zrf = 64'hBFF0000000000000; - ans = 64'h41B2D2609AFCA62D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1791037\n"); - end - xrf = 64'h4000000000000001; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hC7F015AE3F3AD1AC; - ans = 64'hC7F015AE3F3AD1AC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1791651\n"); - end - xrf = 64'h802FF80000003FFE; - y = 64'h3F20000800003FFE; - zrf = 64'h3F6423F1E5D3FBF4; - ans = 64'h3F6423F1E5D3FBF4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1792265\n"); - end - xrf = 64'h3FC1E7598F9CD086; - y = 64'hBFE0000000000000; - zrf = 64'h0010000000000000; - ans = 64'hBFB1E7598F9CD086; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1792879\n"); - end - xrf = 64'h4000000000000001; - y = 64'h3FE003FFFF800000; - zrf = 64'hC01DFFEFFFFFFFFF; - ans = 64'hC019FEF0001FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1793493\n"); - end - xrf = 64'hC000002FFFFFFFFF; - y = 64'hBFE0000000000001; - zrf = 64'hB7F000DFFFFFFFFE; - ans = 64'h3FF0003000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1794107\n"); - end - xrf = 64'h4000000000000001; - y = 64'hBFA0000000000FFB; - zrf = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1794721\n"); - end - xrf = 64'hC03DC1C014713559; - y = 64'hB7FFFFFFFC002000; - zrf = 64'h3F9FFFEFFFDFFFFE; - ans = 64'h3F9FFFEFFFDFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1795335\n"); - end - xrf = 64'h4000000000000001; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1795949\n"); - end - xrf = 64'h01F748C86FB03473; - y = 64'hC7FB8788D6F9E4E6; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1796563\n"); - end - xrf = 64'h4000000000000001; - y = 64'hBFF0000000000001; - zrf = 64'h3F5F800000040000; - ans = 64'hBFFFF81FFFFFFF04; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1797177\n"); - end - xrf = 64'hBCA00000EFFFFFFF; - y = 64'h43C400003FFFFFFF; - zrf = 64'h3CA00007FFFFC000; - ans = 64'hC07400016C0003BE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1797791\n"); - end - xrf = 64'hC1F3FFFFFFFFFFE0; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h0000000000000001; - ans = 64'h4203FFFFFFFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1798405\n"); - end - xrf = 64'h4000000000000001; - y = 64'h43DF000007FFFFFE; - zrf = 64'h40100008FFFFFFFF; - ans = 64'h43EF000008000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1799019\n"); - end - xrf = 64'hC3F2E23919B19F0E; - y = 64'hC000000000000000; - zrf = 64'h7FE98F5A17F2E86E; - ans = 64'h7FE98F5A17F2E86E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1799633\n"); - end - xrf = 64'h4000000000000001; - y = 64'h41E609ACC408B524; - zrf = 64'h4010000000000001; - ans = 64'h41F609ACC448B525; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1800247\n"); - end - xrf = 64'h4080001003FFFFFE; - y = 64'hB81FFFF800080000; - zrf = 64'h40D1000000800000; - ans = 64'h40D1000000800000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1800861\n"); - end - xrf = 64'h4000000000000001; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1801475\n"); - end - xrf = 64'h8017FF8000000000; - y = 64'h747FFFFFFFFFFFFF; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1802089\n"); - end - xrf = 64'h4000000000000001; - y = 64'hC010000000000000; - zrf = 64'hBFEFFFFFFFFFFFE4; - ans = 64'hC021FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1802703\n"); - end - xrf = 64'hC07000000100001F; - y = 64'hC0E4D4E49ACE0434; - zrf = 64'hBFCFFFFFDFFFFF80; - ans = 64'h4164D4E4941B52AE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1803317\n"); - end - xrf = 64'h46B0027FFFFFFFFF; - y = 64'hC010000000000001; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1803931\n"); - end - xrf = 64'h4000000000000001; - y = 64'hBFD11F7A827D1E2E; - zrf = 64'h4005DD80C016477D; - ans = 64'h400195A21F76FFF1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1804545\n"); - end - xrf = 64'hFFFE280615241B91; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h79AFFF03FFFFFFFE; - ans = 64'hFFFE280615241B91; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1805159\n"); - end - xrf = 64'h4000000000000001; - y = 64'hC7EBFFFE00000000; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'hC7FBFFFE00000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1805773\n"); - end - xrf = 64'hBE27ECA300A3042F; - y = 64'hFFD60AAFC2B75EE4; - zrf = 64'h3E703FFFFFFEFFFF; - ans = 64'h7E107AAD6B0F65B7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1806387\n"); - end - xrf = 64'h4000000000000001; - y = 64'hC340000000000001; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC350000000000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1807001\n"); - end - xrf = 64'h402FF000001FFFFF; - y = 64'hCCAFF1B2E8DEC363; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hCCEFE1BA0F8A45B3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1807615\n"); - end - xrf = 64'h4000000000000001; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h37E007FFFFFFFBFF; - ans = 64'hC360000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1808229\n"); - end - xrf = 64'hBFBFEFFFFFFFFFFB; - y = 64'h117FFE000003FFFF; - zrf = 64'hC0107437118816CB; - ans = 64'hC0107437118816CB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1808843\n"); - end - xrf = 64'hF4D0000400000FFE; - y = 64'hFFE0000000000000; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1809457\n"); - end - xrf = 64'h4000000000000001; - y = 64'hCA0FFFFFFDFFFBFF; - zrf = 64'h43E0000200000002; - ans = 64'hCA1FFFFFFDFFFC01; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1810071\n"); - end - xrf = 64'hB7EF275E3109EBEA; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hD600000FFFFFFFBF; - ans = 64'h77EF275E3109EBE9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1810685\n"); - end - xrf = 64'h4000000000000001; - y = 64'h41F07FE000000000; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h42007FE000100001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1811299\n"); - end - xrf = 64'hFFFFFFFFFFF7FFFA; - y = 64'h361FFFFFFFF0003E; - zrf = 64'hBFCDE782F05F6E29; - ans = 64'hFFFFFFFFFFF7FFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1811913\n"); - end - xrf = 64'h4000000000000001; - y = 64'hFFF0000000000000; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1812527\n"); - end - xrf = 64'hBF83BAA79E85EC1A; - y = 64'h3FBFFFFFFFE003FE; - zrf = 64'hBCA0000000000000; - ans = 64'hBF53BAA79E7235E8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1813141\n"); - end - xrf = 64'h4000000000000001; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h7FD8000000FFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1813755\n"); - end - xrf = 64'hBFEFF5F3E00E51FC; - y = 64'h381AA9A05DB030CE; - zrf = 64'hC01FFFFFDFFFFF7F; - ans = 64'hC01FFFFFDFFFFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1814369\n"); - end - xrf = 64'hB800001FFF7FFFFF; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'hFFE0000000000000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1814983\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h7EEA3D84C3E981AE; - zrf = 64'h3FF0000000001F7F; - ans = 64'h7F0A3D84C3E981AD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1815597\n"); - end - xrf = 64'hBFEFFFFFFFEFFFFC; - y = 64'h0000000000000001; - zrf = 64'h41B0001800000000; - ans = 64'h41B0001800000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1816211\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h37EFFFFFE0FFFFFF; - zrf = 64'h3FF0000000000000; - ans = 64'h3FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1816825\n"); - end - xrf = 64'h5BE66EEA72E09608; - y = 64'h4346A605EF720221; - zrf = 64'h001FFFFF03FFFFFE; - ans = 64'h5F3FC14970BE939C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1817439\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hC000000000000000; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1818053\n"); - end - xrf = 64'hD0C00FFFEFFFFFFE; - y = 64'h434FFFEFFFFFFBFE; - zrf = 64'h8010000000000001; - ans = 64'hD4200FF7E80005FB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1818667\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h0010000000000001; - zrf = 64'h43D844324AC65C66; - ans = 64'h43D844324AC65C66; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1819281\n"); - end - xrf = 64'hC03A841F0672CCEA; - y = 64'hBFFFEFFFFFDFFFFE; - zrf = 64'hC10E000200000000; - ans = 64'hC10DFE5A923092AF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1819895\n"); - end - xrf = 64'h91C0000004008000; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hC340000000000001; + z = 64'hC340000000000000; ans = 64'hC340000000000001; rn = 1; rz = 0; @@ -139366,19 +35400,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -139394,12 +35428,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1820509\n"); + $fwrite(fp,"1516541\n"); end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hB81002003FFFFFFF; - zrf = 64'h2C58001FFFFFFFFF; - ans = 64'hB83002003FFFFFFE; + x = 64'hBFA0001000000000; + y = 64'hC000000000000000; + z = 64'h219FFFFFFFFFF810; + ans = 64'h3FB0001000000000; rn = 1; rz = 0; rm = 0; @@ -139413,19 +35447,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -139441,12 +35475,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1821123\n"); + $fwrite(fp,"1518555\n"); end - xrf = 64'h3CAFEFFFFFFFFFE0; - y = 64'h3CA0000000000000; - zrf = 64'h3040000000000000; - ans = 64'h395FEFFFFFFFFFE0; + x = 64'h802000000FFFFFF7; + y = 64'hC34FFFFFFFFEFF7F; + z = 64'hC3DF01FFFFFFFFFE; + ans = 64'hC3DF01FFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -139460,19 +35494,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -139488,575 +35522,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1821737\n"); + $fwrite(fp,"1520569\n"); end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hB7EFFFFFE0200000; - zrf = 64'h3FE0000000000001; - ans = 64'h3FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1822351\n"); - end - xrf = 64'hC80FFFFFE0000002; - y = 64'hBF0B6637E256754F; - zrf = 64'h37F66727FC897D25; - ans = 64'h472B6637C6F03D6E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1822965\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hBFF0000000000001; - ans = 64'hBFEFFFFFFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1823579\n"); - end - xrf = 64'h415F800000000100; - y = 64'hC3E0000FFF000000; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'hC54F801F7E080100; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1824193\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h3FD0000000000000; - zrf = 64'h37EBFFFFFFFFFFFC; - ans = 64'h3FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1824807\n"); - end - xrf = 64'h3FE4116E93E56F17; - y = 64'h3FCF7FFFF8000000; - zrf = 64'hC0201007FFFFFFFE; - ans = 64'hC01F8206B95B740E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1825421\n"); - end - xrf = 64'h358000007FFFDFFF; - y = 64'h3FD0000000000001; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1826035\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hC1CFFFF000000040; - zrf = 64'h7FDECC2967860F7E; - ans = 64'h7FDECC2967860F7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1826649\n"); - end - xrf = 64'h3810000003FFFFFD; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h3FC00000001FFE00; - ans = 64'h3FC00000001FFE00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1827263\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hC62FFFF804000000; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'hC64FFFF803FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1827877\n"); - end - xrf = 64'hBFF81F36391021FB; - y = 64'h4050004FFFFFFFFF; - zrf = 64'h6C0FFF807FFFFFFF; - ans = 64'h6C0FFF807FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1828491\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h3FE0000000000001; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1829105\n"); - end - xrf = 64'hC020000000FBFFFE; - y = 64'h407EEFFFFFFFFFFF; - zrf = 64'h7FFFFFFFFFFFFFFE; + x = 64'h3FF0000000000001; + y = 64'hC010000000000001; + z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -140071,19 +35541,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -140099,12 +35569,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1829719\n"); + $fwrite(fp,"1522583\n"); end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h6BD0400000010000; - ans = 64'h6BD0400000010000; + x = 64'h41F03FFFBFFFFFFF; + y = 64'hC340000000000000; + z = 64'h5A2FFDFBFFFFFFFE; + ans = 64'h5A2FFDFBFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -140118,19 +35588,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -140146,12 +35616,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1830333\n"); + $fwrite(fp,"1524597\n"); end - xrf = 64'h4D069B23F868B6DD; - y = 64'hC2600020000FFFFF; - zrf = 64'h0022F3A10B222F4A; - ans = 64'hCF769B512EC742D1; + x = 64'h4816468957EB0E3D; + y = 64'hBFFEA99B5235F21E; + z = 64'hBF1000010000FFFE; + ans = 64'hC825583166A83DE6; rn = 1; rz = 0; rm = 0; @@ -140165,19 +35635,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -140193,12 +35663,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1830947\n"); + $fwrite(fp,"1526611\n"); end - xrf = 64'h372FFFFFFFFE007F; - y = 64'h3FF0000000000000; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFE; + x = 64'h3FF0000000000001; + y = 64'hFFE0000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hFFE0000000000002; rn = 1; rz = 0; rm = 0; @@ -140212,19 +35682,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -140240,528 +35710,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1831561\n"); + $fwrite(fp,"1528625\n"); end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hC3EFFFFF7FFFFEFF; - zrf = 64'hC0E2E2D8FDDA0A73; - ans = 64'hC40FFFFF7FFFFF03; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1832175\n"); - end - xrf = 64'h43C00000007F7FFE; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hBFE20FF482B66D99; - ans = 64'h43D00000007F7FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1832789\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hC3EA35D616039DF4; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'hC40A35D616039DF3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1833403\n"); - end - xrf = 64'hFFEFFFFEFFEFFFFF; - y = 64'hBFDC7B63D40DC944; - zrf = 64'h4460040000000004; - ans = 64'h7FDC7B62F0246CF1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1834017\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h4000000000000000; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'h401DFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1834631\n"); - end - xrf = 64'h402FFFFFFFFFFEFE; - y = 64'h4000007FFFF80000; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1835245\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h800C6068B41C7BB7; - ans = 64'h402FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1835859\n"); - end - xrf = 64'h373CE9EB12A75385; - y = 64'hEAC0002007FFFFFE; - zrf = 64'hAC7007FFBFFFFFFF; - ans = 64'hE20CEA24F4F26E59; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1836473\n"); - end - xrf = 64'h2BB0800000000800; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hC000000000000000; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1837087\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h4B7FFFFFFFFFF03E; - zrf = 64'h3CE080000000FFFF; - ans = 64'h4B9FFFFFFFFFF03D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1837701\n"); - end - xrf = 64'h4530037FFFFFFFFE; - y = 64'h4010000000000001; - zrf = 64'hBF700200000001FF; - ans = 64'h4550037FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1838315\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hFFEF0000003FFFFF; - zrf = 64'h3CA0000000000000; + x = 64'h73D00000001F8000; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h3810800000000800; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -140776,19 +35729,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -140804,12 +35757,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1838929\n"); + $fwrite(fp,"1530639\n"); end - xrf = 64'h3810000001FFFBFF; - y = 64'h57E000F800000000; - zrf = 64'h403000000000C000; - ans = 64'h500000F802001AFF; + x = 64'hBF7107FFFFFFFFFF; + y = 64'h3FDEFFFFFFFFDFFF; + z = 64'hC02010000FFFFFFE; + ans = 64'hC02011080BFFFFFD; rn = 1; rz = 0; rm = 0; @@ -140823,19 +35776,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -140851,12 +35804,576 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1839543\n"); + $fwrite(fp,"1532653\n"); end - xrf = 64'h400FFFFFFFFFFFFF; + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h0000000000000000; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1534667\n"); + end + x = 64'h3BEFE000000FFFFE; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hBFD602A609EE9BAB; + ans = 64'hBFD602A609EE9BAB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1536681\n"); + end + x = 64'hBFF000403FFFFFFF; + y = 64'h3FDF3E0BE31EBEE9; + z = 64'hB802C73B4852E1E1; + ans = 64'hBFDF3E8958467AEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1538695\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h3CA0000000000000; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1540709\n"); + end + x = 64'h3FC0FFFFFFFFFFF7; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hBF8011FFFFFFFFFF; + ans = 64'hBF8011FFFFFFFFEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1542723\n"); + end + x = 64'h37FFFFFF00000006; + y = 64'hC7E00001FFFFFFDE; + z = 64'h41C795C3980A9C95; + ans = 64'h41C795C3978A9C89; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1544737\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1546751\n"); + end + x = 64'h402FFFFDEFFFFFFE; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h43D1A195ABB1C5B6; + ans = 64'h43D1A195ABB1C5B6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1548765\n"); + end + x = 64'h44EFFBDFFFFFFFFF; + y = 64'h321FFFFFFFFF00FF; + z = 64'h1042F2308B3C2796; + ans = 64'h371FFBDFFFFF011F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1550779\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h400FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1552793\n"); + end + x = 64'h41FFFFF7FFBFFFFE; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hBF59AF9A3B538749; + ans = 64'h421FFFF7FFBFFE62; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1554807\n"); + end + x = 64'h4E5F3DCE4E5C17A8; + y = 64'hAEEA7C211E03A2CE; + z = 64'hC00001EFFFFFFFFE; + ans = 64'hC00001F000000339; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1556821\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hBFD0000000000000; - ans = 64'h403FBFFFFFFFFFFD; + z = 64'h3FF0000000000001; + ans = 64'h4030FFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -140870,19 +36387,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -140898,59 +36415,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1840157\n"); + $fwrite(fp,"1558835\n"); end - xrf = 64'h3FCFFFFFFFFF00FE; - y = 64'hC34000FFFFFFFFFD; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1840771\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; + x = 64'h8DDFFFF7FFFFFF7E; y = 64'h4340000000000001; - zrf = 64'h7FFFFFFFFFFFFFDC; - ans = 64'h7FFFFFFFFFFFFFDC; + z = 64'h352C9FA3227CAA38; + ans = 64'h352C9FA3227CAA38; rn = 1; rz = 0; rm = 0; @@ -140964,19 +36434,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -140992,12 +36462,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1841385\n"); + $fwrite(fp,"1560849\n"); end - xrf = 64'hC34AA4AD5429CD0E; - y = 64'h002FFFFC00FFFFFE; - zrf = 64'h0010100000200000; - ans = 64'h838AA4AA006947F2; + x = 64'h2080001000FFFFFF; + y = 64'hC1C000800001FFFE; + z = 64'hC1F4007FFFFFFFFE; + ans = 64'hC1F4007FFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -141011,19 +36481,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -141039,246 +36509,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1841999\n"); + $fwrite(fp,"1562863\n"); end - xrf = 64'hC34FFFF800000010; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'hBFF0000000000001; - ans = 64'hC6AFFFF80000000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1842613\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h638FFFFFFAFFFFFF; - zrf = 64'hC1CFFFFFF8007FFE; - ans = 64'h63AFFFFFFAFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1843227\n"); - end - xrf = 64'hB7FF7FFFFFFFF000; - y = 64'h7FE0000000000000; - zrf = 64'h78B01FFFEFFFFFFF; - ans = 64'h78B01F03F0000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1843841\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hBFCFFFFF04000000; - zrf = 64'h0010000000000001; - ans = 64'hBFEFFFFF03FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1844455\n"); - end - xrf = 64'h3806DE6D558BFE8E; - y = 64'hC06FB4D241F29CCB; - zrf = 64'h3C7C9728EFA05491; - ans = 64'h3C7C9728EFA05491; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1845069\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; + x = 64'h3FFFFFFFFFFFFFFF; y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hBCA0000000000001; + z = 64'hC340000000000000; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -141293,19 +36528,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -141321,152 +36556,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1845683\n"); + $fwrite(fp,"1564877\n"); end - xrf = 64'hBFD0000FFF7FFFFE; - y = 64'h5500001FFFFFBFFF; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'hD4E0002FFF9FBEFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1846297\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h7FF0000000000000; - zrf = 64'h37EB9B5ABEC6C2F2; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1846911\n"); - end - xrf = 64'h7FD00005FFFFFFFE; - y = 64'h41FFFFFFFFFFFFFF; - zrf = 64'h43DFFFF7FFFFFFBF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1847525\n"); - end - xrf = 64'hC1EFFFFFFF81FFFE; + x = 64'h480FF84D125A7C3B; y = 64'h7FF0000000000001; - zrf = 64'hBFEFFFFFFFFFFFFF; + z = 64'h43EBFFFFFFFFFF7F; ans = 64'h7FF8000000000001; rn = 1; rz = 0; @@ -141481,19 +36575,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -141509,12 +36603,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1848139\n"); + $fwrite(fp,"1566891\n"); end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h7FF00000000107FF; - zrf = 64'hC01000FFFFFFFF00; - ans = 64'h7FF80000000107FF; + x = 64'hBEBFFFFFFFFFFFFF; + y = 64'h3CA000007FEFFFFE; + z = 64'hC7CF6EC72066389A; + ans = 64'hC7CF6EC72066389A; rn = 1; rz = 0; rm = 0; @@ -141528,19 +36622,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -141556,11 +36650,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1848753\n"); + $fwrite(fp,"1568905\n"); end - xrf = 64'hC34DFFFFFFF80000; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h40B0003FFFFFDFFE; + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -141575,19 +36669,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -141603,11 +36697,1421 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1849367\n"); + $fwrite(fp,"1570919\n"); end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h7FDFFEEFFFFFFFFF; - zrf = 64'h000FFFFFFFFFFFFF; + x = 64'h43CD3C8F860948FC; + y = 64'h8010000000000001; + z = 64'hBCAFF7FFFFFFF000; + ans = 64'hBCAFF7FFFFFFF000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1572933\n"); + end + x = 64'hC1FFC4B612DC685B; + y = 64'h37EECB94D4DFCE99; + z = 64'h6C10000002001FFE; + ans = 64'h6C10000002001FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1574947\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1576961\n"); + end + x = 64'h4C500FFF00000000; + y = 64'hBFD0000000000000; + z = 64'h403FFFFFFFFFFFFF; + ans = 64'hCC300FFF00000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1578975\n"); + end + x = 64'hBFF000000020007F; + y = 64'hC1E00001FFFFFFDE; + z = 64'hBE80003FFFFFFFFD; + ans = 64'h41E0000200200061; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1580989\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hBFE0000000000001; + z = 64'hBFF0000000000001; + ans = 64'hC000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1583003\n"); + end + x = 64'h3FDFFFFFFFFFDFF7; + y = 64'hBFF0000000000000; + z = 64'hBFB503DCF633DA77; + ans = 64'hBFE2A07B9EC66B4A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1585017\n"); + end + x = 64'hC7EFFFFF7FFFFFF8; + y = 64'h362AE3F6FB550D7A; + z = 64'hC3D87959643FFA05; + ans = 64'hC3D87959643FFA05; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1587031\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hC000000000000001; + z = 64'h4340000000000000; + ans = 64'h433FFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1589045\n"); + end + x = 64'h47F0000003FFBFFE; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hB7E040001FFFFFFE; + ans = 64'hC810000003FFBFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1591059\n"); + end + x = 64'hC1ED0FDDB8CC4595; + y = 64'hC02000003FFFFBFF; + z = 64'hB8025D3A7A488076; + ans = 64'h421D0FDE2D0BB532; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1593073\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + 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,"1595087\n"); + end + x = 64'h495003D31DDD9B75; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h480956CD1FF74A85; + ans = 64'hCCB003D31DDD9B74; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1597101\n"); + end + x = 64'h3FCFFFFFBFFFFFFC; + y = 64'h86F0000083FFFFFF; + z = 64'hD1D00000000FFF7F; + ans = 64'hD1D00000000FFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1599115\n"); + end + x = 64'h3FFFFFFFFFFFFFFF; + y = 64'hFFF0000000000000; + 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,"1601129\n"); + end + x = 64'h3C409FFFFFFFFFFE; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hC0700200FFFFFFFF; + 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,"1603143\n"); + end + x = 64'hC2700007FFFFFFF8; + y = 64'h3FD0000041FFFFFE; + z = 64'h5EE41DC74D68BD8D; + ans = 64'h5EE41DC74D68BD8D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1605157\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h0010000000000000; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1607171\n"); + end + x = 64'hBFE00FEFFFFFFFFF; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hC0200000021FFFFE; + ans = 64'hC0200000021FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1609185\n"); + end + x = 64'hC00F800000002000; + y = 64'h3FC7FFFBFFFFFFFF; + z = 64'hC6EFFE0000800000; + ans = 64'hC6EFFE0000800000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1611199\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1613213\n"); + end + x = 64'h0007FFFFFFFBFFFE; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h3FB0000008000000; + ans = 64'h3FB0000008000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1615227\n"); + end + x = 64'hD329292015820F2A; + y = 64'hC03FFFFFFFFFFBEF; + z = 64'h40557E8B8D949070; + ans = 64'h5379292015820BF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1617241\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + 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,"1619255\n"); + end + x = 64'hBFB0200001000000; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h3EC000000007FFF7; + ans = 64'hBFC01FF000FFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1621269\n"); + end + x = 64'hC3E76F2C56D0D8D0; + y = 64'hC04FC00000000020; + z = 64'h42EF800000000007; + ans = 64'h4447404E7C233736; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1623283\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h401FFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1625297\n"); + end + x = 64'h401FFFFFDEFFFFFF; + y = 64'h4010000000000001; + z = 64'h3FDC00000FFFFFFF; + ans = 64'h404037FFEFA00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1627311\n"); + end + x = 64'hC0BFFFFFFFFFFDC0; + y = 64'h4E3FFFFBFBFFFFFF; + z = 64'hBFC0000081000000; + ans = 64'hCF0FFFFBFBFFFDBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1629325\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'h435FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1631339\n"); + end + x = 64'h43423BCFF86BBAE2; + y = 64'h7FE0000000000001; + z = 64'h7FE4C40B5E3A4BEC; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -141622,19 +38126,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -141650,12 +38154,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1849981\n"); + $fwrite(fp,"1633353\n"); end - xrf = 64'h4800000010000040; - y = 64'h400ED4F0320ECE0D; - zrf = 64'h4345D3E889C98140; - ans = 64'h481ED4F050E3BEBA; + x = 64'hBCA0000DFFFFFFFF; + y = 64'hB8500000000FFFEE; + z = 64'h36C9B3089EDD6940; + ans = 64'h36C9B3089FDD6A20; rn = 1; rz = 0; rm = 0; @@ -141669,19 +38173,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -141697,12 +38201,1704 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1850595\n"); + $fwrite(fp,"1635367\n"); end - xrf = 64'h400FFFFFFFFFFFFF; + x = 64'h3FFFFFFFFFFFFFFE; + 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,"1637381\n"); + end + x = 64'hC3CFFFDFFFE00000; + y = 64'h8000000000000000; + z = 64'hC1C001FFFDFFFFFF; + ans = 64'hC1C001FFFDFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1639395\n"); + end + x = 64'h456000020007FFFE; + y = 64'h401BE502A9566269; + z = 64'hC23D72CB92AE4C26; + ans = 64'h458BE5062604AA11; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1641409\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + 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,"1643423\n"); + end + x = 64'h3ECFFFDFFFFEFFFE; + y = 64'hBCA0000000000000; + z = 64'h0CCFFFFF00000006; + ans = 64'hBB7FFFDFFFFEFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1645437\n"); + end + x = 64'h43EFFFEFFFFFFF7F; + y = 64'hC020001FFFFFE000; + z = 64'h4039E58242A7C1BA; + ans = 64'hC4200017FFEFDFC0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1647451\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'hBFD0000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBFE0000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1649465\n"); + end + x = 64'hC3F23B5D47B0FEA9; + y = 64'hBFE0000000000000; + z = 64'hD9FFFFFFFFFFDFFF; + ans = 64'hD9FFFFFFFFFFDFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1651479\n"); + end + x = 64'h414FF8FFFFFFFFFE; + y = 64'h380000004000001F; + z = 64'h8021FFFFFFFFFFFE; + ans = 64'h395FF9007FE4003C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1653493\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'hBFF0000000000001; + z = 64'h3FF0000000000001; + ans = 64'hBFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1655507\n"); + end + x = 64'hC80FFFBBFFFFFFFE; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hBF0000103FFFFFFE; + ans = 64'h481FFFBBFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1657521\n"); + end + x = 64'hE09FF8003FFFFFFF; + y = 64'h4D3000000011FFFF; + z = 64'h40300FFFFFFFFFF6; + ans = 64'hEDDFF8004023F6FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1659535\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + y = 64'hC010000000000000; + z = 64'hC340000000000000; + ans = 64'hC340000000000004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1661549\n"); + end + x = 64'h3FF003FFFFFEFFFF; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hC5404000003FFFFF; + ans = 64'hC5404000003FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1663563\n"); + end + x = 64'hBFBF80000001FFFF; + y = 64'h3F3FFFFFFFEFFFDF; + z = 64'h3FC573070215E3AE; + ans = 64'h3FC5710F0215E48A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1665577\n"); + end + x = 64'h3FFFFFFFFFFFFFFE; + 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,"1667591\n"); + end + x = 64'hBFC48FB834ECE0DD; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hC00FEFFFFFFEFFFE; + ans = 64'h7FC48FB834ECE0DC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1669605\n"); + end + x = 64'hC01FFF7FFFBFFFFF; + y = 64'hFF3E51ACA009FA27; + z = 64'h8010000400020000; + ans = 64'h7F6E5133591AD6A5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1671619\n"); + end + x = 64'h4000000000000000; + y = 64'h0000000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1673633\n"); + end + x = 64'hBFBFFFFF007FFFFF; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h000BFFFFFFC00000; + ans = 64'h000A00000FB80000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1675647\n"); + end + x = 64'h3EEFFFFFFFFFFBFE; + y = 64'hBFA78BDE48D46AE7; + z = 64'hBE6413896FF4D5BD; + ans = 64'hBEA8CD16DFD3B550; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1677661\n"); + end + x = 64'h4000000000000000; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1679675\n"); + end + x = 64'h47F0000002000000; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hC5FFFDFFFFFFE000; + ans = 64'hC5FFFDFEFFFFDFE0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1681689\n"); + end + x = 64'h3E707FFFFFFFFEFE; + y = 64'h401FFFFFDF000000; + z = 64'h8000DF3AAECD13EB; + ans = 64'h3EA07FFFEEFBFEFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1683703\n"); + end + x = 64'h4000000000000000; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1685717\n"); + end + x = 64'hBEFFFFD000000000; + y = 64'h3FE0000000000001; + z = 64'hC3D0000000007FBE; + ans = 64'hC3D0000000007FBE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1687731\n"); + end + x = 64'hC80FFFFFFFF7FFF6; + y = 64'h400FFFFEFFFFBFFF; + z = 64'hBFB38D0D6D9F1DF5; + ans = 64'hC82FFFFEFFF7BFF5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1689745\n"); + end + x = 64'h4000000000000000; + 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,"1691759\n"); + end + x = 64'hFFD000000000000F; + y = 64'h4000000000000001; + z = 64'hBEE727C6C2939AC7; + ans = 64'hFFE0000000000010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1693773\n"); + end + x = 64'hBECFFFFFF8000003; + y = 64'h2EB5B3F4AF3D7BF6; + z = 64'h41307FFFFFFFFFBF; + ans = 64'h41307FFFFFFFFFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1695787\n"); + end + x = 64'h4000000000000000; + y = 64'h401FFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h402FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1697801\n"); + end + x = 64'hBFD0FFFFF7FFFFFF; + y = 64'h4340000000000001; + z = 64'hC0B0002000001FFE; + ans = 64'hC320FFFFF8002000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1699815\n"); + end + x = 64'h3FC03FFFFFFFFFF7; + y = 64'hFFEAD8BEE9B8973A; + z = 64'h3FEF000008000000; + ans = 64'hFFBB4421E55F7988; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1701829\n"); + end + x = 64'h4000000000000000; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1703843\n"); + end + x = 64'hC4A72CA6B0DBBC07; + y = 64'h7FF0000000000000; + z = 64'h3C340000000000FF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1705857\n"); + end + x = 64'h3FB000101FFFFFFF; + y = 64'hB0D2D32BC2E62804; + z = 64'h8010002007FFFFFF; + ans = 64'hB092D33EBBB8426F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1707871\n"); + end + x = 64'h4000000000000000; y = 64'h8000000000000001; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h8020000000000001; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; rn = 1; rz = 0; rm = 0; @@ -141716,19 +39912,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -141744,11 +39940,2267 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1851209\n"); + $fwrite(fp,"1709885\n"); end - xrf = 64'hFFE004000000001F; - y = 64'hD01D0009A1468219; - zrf = 64'h401FFFFFFFFFFFFE; + x = 64'h0000FF0000000000; + y = 64'h8010000000000000; + z = 64'hC000000401FFFFFE; + ans = 64'hC000000401FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1711899\n"); + end + x = 64'hC0332683837CE949; + y = 64'hC0F000000800FFFF; + z = 64'h41E0000000000FFF; + ans = 64'h41E00264D071B22B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1713913\n"); + end + x = 64'h4000000000000000; + 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,"1715927\n"); + end + x = 64'h4A1003FFFF7FFFFF; + y = 64'hBFD0000000000000; + z = 64'h3CA000FFFFFFF000; + ans = 64'hC9F003FFFF7FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1717941\n"); + end + x = 64'hC00DFFFFFFFFEFFF; + y = 64'hBE500003FEFFFFFF; + z = 64'h39CFFFFEFFFFFFBF; + ans = 64'h3E6E00077E1FEFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1719955\n"); + end + x = 64'h4000000000000000; + y = 64'hBFE0000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hBFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1721969\n"); + end + x = 64'hC1D0001000200000; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hBB000010FFFFFFFE; + ans = 64'h41D00010001FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1723983\n"); + end + x = 64'hBFD00203FFFFFFFF; + y = 64'h40E8CD2DEA9DB561; + z = 64'hE40FE0000000FFFF; + ans = 64'hE40FE0000000FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1725997\n"); + end + x = 64'h4000000000000000; + y = 64'hC000000000000000; + z = 64'hBFF0000000000001; + ans = 64'hC014000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1728011\n"); + end + x = 64'hBFCFBFFFFFFFFBFF; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h381E7BECF1508167; + ans = 64'h3FEFBFFFFFFFFBFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1730025\n"); + end + x = 64'hC1DF000000004000; + y = 64'h3E46552EF24D77CA; + z = 64'h402403FFFFFFFFFF; + ans = 64'hC027410AF576716D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1732039\n"); + end + x = 64'h4000000000000000; + y = 64'hC340000000000000; + z = 64'h4340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1734053\n"); + end + x = 64'hBD6FFFF800000040; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hC06FFFFFFA000000; + ans = 64'h40CF7FF80018003F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1736067\n"); + end + x = 64'h4B3FFFFFFFFFE010; + y = 64'hC12FFF7FFFE00000; + z = 64'hBF6EE7B3B6726BD9; + ans = 64'hCC7FFF7FFFDFE010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1738081\n"); + end + x = 64'h4000000000000000; + 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,"1740095\n"); + end + x = 64'hBC5FFFFFFFFFFCFE; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hBCA00000008000FF; + 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,"1742109\n"); + end + x = 64'h64D000001FFFF7FF; + y = 64'h4A300000007FBFFF; + z = 64'h41C0000FFFF00000; + ans = 64'h6F100000207FB7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1744123\n"); + end + x = 64'h4000000000000001; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1746137\n"); + end + x = 64'hC340000000004100; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h3FB9F4A28A317BA3; + ans = 64'h3FB9F4A28A317BA3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1748151\n"); + end + x = 64'hAC733AF5CC6534E5; + y = 64'hBFBFFFFFFFFFE003; + z = 64'hBE7FFFFFFF800040; + ans = 64'hBE7FFFFFFF800040; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1750165\n"); + end + x = 64'h4000000000000001; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1752179\n"); + end + x = 64'hC34407FFFFFFFFFF; + y = 64'h3FD0000000000001; + z = 64'h434EE78A270158C4; + ans = 64'h4349E58A270158C4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1754193\n"); + end + x = 64'hBEF0000040002000; + y = 64'hC00FFFDFFFFEFFFF; + z = 64'h3F94C3676CE5C5C1; + ans = 64'h3F94D3675D25C521; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1756207\n"); + end + x = 64'h4000000000000001; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC33FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1758221\n"); + end + x = 64'h3C5FC00000000000; + y = 64'h3FF0000000000001; + z = 64'hC3400013FFFFFFFE; + ans = 64'hC3400013FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1760235\n"); + end + x = 64'hB7FFFFFF807FFFFF; + y = 64'h4000000000014000; + z = 64'h40B000400000001E; + ans = 64'h40B000400000001E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1762249\n"); + end + x = 64'h4000000000000001; + y = 64'h400FFFFFFFFFFFFF; + 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,"1764263\n"); + end + x = 64'hC3FAF4D1799B420E; + y = 64'h4010000000000001; + z = 64'hC3335809BE152176; + ans = 64'hC41AF51ED9C23A64; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1766277\n"); + end + x = 64'h4020FEFFFFFFFFFE; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h402FC3FFFFFFFFFE; + ans = 64'hC04A0CFFFFFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1768291\n"); + end + x = 64'h4000000000000001; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h4360000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1770305\n"); + end + x = 64'hFFF13EF189994B39; + y = 64'h7FE0000000000000; + z = 64'hC80FFF7FFC000000; + ans = 64'hFFF93EF189994B39; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1772319\n"); + end + x = 64'h41F00000007FE000; + y = 64'hCEFF8000000003FF; + z = 64'h445FFFFFFFFFFFFF; + ans = 64'hD0FF800000FBC4FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1774333\n"); + end + x = 64'h4000000000000001; + y = 64'h7FF0000000000001; + z = 64'hBFF0000000000001; + 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,"1776347\n"); + end + x = 64'hC3E0000FFFFFFFFE; + y = 64'h8000000000000000; + z = 64'hFFD002FFFFFFFFFF; + ans = 64'hFFD002FFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1778361\n"); + end + x = 64'h3FFFFF7EFFFFFFFF; + y = 64'h380FFFFF001FFFFF; + z = 64'hBFF0080000800000; + ans = 64'hBFF0080000800000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1780375\n"); + end + x = 64'h4000000000000001; + y = 64'h8010000000000001; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1782389\n"); + end + x = 64'h800F00FFFFFFFFFF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hBF4DDFFFFFFFFFFF; + ans = 64'hBF4DDFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1784403\n"); + end + x = 64'h3EFFFFFFFE000040; + y = 64'hBC1000000000207F; + z = 64'h40EFFFFFFFFDC000; + ans = 64'h40EFFFFFFFFDC000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1786417\n"); + end + x = 64'h4000000000000001; + y = 64'hBFD0000000000000; + 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,"1788431\n"); + end + x = 64'hC3CFFFFFFDFFEFFF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hBFC0000003FFBFFF; + ans = 64'h43BFFFFFFDFFEFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1790445\n"); + end + x = 64'h402000000011FFFE; + y = 64'h802FFFFFFFFFFFFF; + z = 64'hC00FFFE000000001; + ans = 64'hC00FFFE000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1792459\n"); + end + x = 64'h4000000000000001; + y = 64'hBFF0000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hC000000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1794473\n"); + end + x = 64'h3F2FFFDDFFFFFFFF; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hC1E00000001003FE; + ans = 64'hC1E00000001007FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1796487\n"); + end + x = 64'hC3F46EB7D64DB1F9; + y = 64'hC3D54F7FFD12E189; + z = 64'h7FF07FFFFFFFFFDF; + ans = 64'h7FF87FFFFFFFFFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1798501\n"); + end + x = 64'h4000000000000001; + y = 64'hC010000000000000; + z = 64'h3FF0000000000001; + ans = 64'hC01C000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1800515\n"); + end + x = 64'h002FFFFBFDFFFFFF; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hC1CFFFFF7FF7FFFF; + ans = 64'hC1CFFFFF7FF7FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1802529\n"); + end + x = 64'h37EFFFFFFFFFFF83; + y = 64'h43E3FFFFFF800000; + z = 64'h402008000001FFFF; + ans = 64'h402008000001FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1804543\n"); + end + x = 64'h4000000000000001; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'hC364000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1806557\n"); + end + x = 64'hFFD7A538500A7D7A; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hA2C407EC69F1CC61; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -141763,19 +42215,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -141791,12 +42243,952 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1851823\n"); + $fwrite(fp,"1808571\n"); end - xrf = 64'h400FFFFFFFFFFFFF; + x = 64'h3FD0005FFFFFFFFE; + y = 64'hC3E411C0691B2909; + z = 64'hC34FFFFFF81FFFFF; + ans = 64'hC3C43238D395BFA9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1810585\n"); + end + x = 64'h4000000000000001; + y = 64'hFFFFFFFFFFFFFFFE; + 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,"1812599\n"); + end + x = 64'hC3D02003FFFFFFFE; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h415FFFFFEFFE0000; + ans = 64'h415FFFFFEFFE0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1814613\n"); + end + x = 64'hC1C01F7FFFFFFFFF; + y = 64'hC0CBFFFFF8000000; + z = 64'hBFE0000002000004; + ans = 64'h429C371FF7F03DFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1816627\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1818641\n"); + end + x = 64'hBFF73733471D9EB9; + y = 64'h3CA0000000000001; + z = 64'h47E000000FFFBFFF; + ans = 64'h47E000000FFFBFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1820655\n"); + end + x = 64'hB81FFFFFFFFF0FFE; + y = 64'hC3DFFF0000002000; + z = 64'h801C000003FFFFFE; + ans = 64'h3C0FFEFFFFFF3006; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1822669\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'h3FEFFFFFFFFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1824683\n"); + end + x = 64'hC1C0000000000FDE; + y = 64'h3FE0000000000001; + z = 64'h41D4CBFF08B3D9B1; + ans = 64'h41D0CBFF08B3D5B9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1826697\n"); + end + x = 64'hB8D3FFFFFF000000; + y = 64'hC3D5607787B731DA; + z = 64'hFFDFFFFFFFFFFFFE; + ans = 64'hFFDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1828711\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h4340000000000004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1830725\n"); + end + x = 64'hA2BF875A03F685CD; + y = 64'h4000000000000000; + z = 64'hC34FC0000000001F; + ans = 64'hC34FC0000000001F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1832739\n"); + end + x = 64'h43FFFF000001FFFE; + y = 64'h3F4FFFFFFFFF3FFF; + z = 64'h800FFEFFFFFFFEFF; + ans = 64'h435FFF0000014003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1834753\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h4010000000000001; + 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,"1836767\n"); + end + x = 64'hC03F8000000000FE; + y = 64'h4340000000000000; + z = 64'hC1C0040000000007; + ans = 64'hC38F8000010040FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1838781\n"); + end + x = 64'hBFCFFFFFDFFFF7FF; + y = 64'hBCF0000400003FFE; + z = 64'hC0689FA5E30DF9AB; + ans = 64'hC0689FA5E30DF9AB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1840795\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h7FE0000000000001; + 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,"1842809\n"); + end + x = 64'h41D1F471DB7E29ED; + y = 64'h7FF0000000000000; + z = 64'h884400000000FFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1844823\n"); + end + x = 64'hDF800007FFFFFFFF; + y = 64'hBE700000080001FE; + z = 64'hC7EFFFF0000000FF; + ans = 64'h5E000008080005FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1846837\n"); + end + x = 64'h400FFFFFFFFFFFFF; + y = 64'h8000000000000001; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1848851\n"); + end + x = 64'hCBE2B464D5FB92A3; y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h7F20001040000000; - ans = 64'h7F20001040000000; + z = 64'hC6DFFFFFFFFFFFFE; + ans = 64'hC6DFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -141810,19 +43202,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -141838,12 +43230,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1852437\n"); + $fwrite(fp,"1850865\n"); end - xrf = 64'hB80F1FFFFFFFFFFE; - y = 64'h3F8000000007FDFF; - zrf = 64'hB7F000FFFFFFDFFF; - ans = 64'hB7F07D8000001E2F; + x = 64'h4F9FFFFF000003FF; + y = 64'h41CF8000FFFFFFFE; + z = 64'h4047FFFFFBFFFFFF; + ans = 64'h517F800003FFFBED; rn = 1; rz = 0; rm = 0; @@ -141857,19 +43249,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -141885,12 +43277,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1853051\n"); + $fwrite(fp,"1852879\n"); end - xrf = 64'hB8000000000017FF; - y = 64'h8010000000000000; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; + x = 64'h400FFFFFFFFFFFFF; + y = 64'hBCA0000000000000; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; rn = 1; rz = 0; rm = 0; @@ -141904,113 +43296,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1853665\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hC1EFFFF900000000; - zrf = 64'h3FF9BEB5ED8496DD; - ans = 64'hC20FFFF8FFF320A4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1854279\n"); - end - xrf = 64'h380FC00003FFFFFF; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h3FC54CA808F073E0; - ans = 64'h3FC54CA808F073E0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -142028,292 +43326,10 @@ initial if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); $fwrite(fp,"1854893\n"); end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h381F7FBFFFFFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1855507\n"); - end - xrf = 64'h375FFFDFFFF7FFFF; - y = 64'hC3EFFFFFFFBFFFF6; - zrf = 64'h38EF7F0000000000; - ans = 64'hBB5FFFDFFFB7C137; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1856121\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hBCA0000000000000; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hBCBFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1856735\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h40303FFFDFFFFFFE; - zrf = 64'h4010000000000000; - ans = 64'hC0107FFFBFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1857349\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'hC031FFFFF7FFFFFF; - ans = 64'hC031FFFFF7FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1857963\n"); - end - xrf = 64'h3E1DFFFFFFFEFFFF; - y = 64'h816FFFFF7FFFFBFE; - zrf = 64'h3F4FFEFFFFFFBFFE; - ans = 64'h3F4FFEFFFFFFBFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1858577\n"); - end - xrf = 64'h37FFA1D0ECBF6C4F; + x = 64'h3FE007FFBFFFFFFE; y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hBFD0000000000000; - ans = 64'hBFD0000000000000; + z = 64'h3FF207FFFFFFFFFE; + ans = 64'h3FF207FFFFFFFFFD; rn = 1; rz = 0; rm = 0; @@ -142327,19 +43343,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -142355,12 +43371,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1859191\n"); + $fwrite(fp,"1856907\n"); end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h3810CD5B23763DB0; - zrf = 64'h37FDDD58B748F787; - ans = 64'h3832AB30AEEACD28; + x = 64'hC02FFFFFBFFFFFEF; + y = 64'h8003FFFFFFFFF800; + z = 64'hF00FFFFFFDFC0000; + ans = 64'hF00FFFFFFDFC0000; rn = 1; rz = 0; rm = 0; @@ -142374,19 +43390,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -142402,12 +43418,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1859805\n"); + $fwrite(fp,"1858921\n"); end - xrf = 64'hC1F000403FFFFFFF; - y = 64'hBFD0000000000001; - zrf = 64'h43400001FFFF0000; - ans = 64'h434000021FFF8080; + x = 64'h400FFFFFFFFFFFFF; + y = 64'hBFE0000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -142421,19 +43437,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -142449,12 +43465,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1860419\n"); + $fwrite(fp,"1860935\n"); end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h7122319B49C3C14C; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; + x = 64'hC03100000001FFFF; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h414FFFFF800FFFFF; + ans = 64'h4150000400080000; rn = 1; rz = 0; rm = 0; @@ -142468,19 +43484,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -142496,12 +43512,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1861033\n"); + $fwrite(fp,"1862949\n"); end - xrf = 64'hBF100FFFF7FFFFFF; - y = 64'hC00FFFC0000003FE; - zrf = 64'hA5AFFFFE0001FFFE; - ans = 64'h3F300FDFD8001200; + x = 64'h402FFFFFE0040000; + y = 64'hC3EA62ADD43FE399; + z = 64'hC3D000001E000000; + ans = 64'hC42AE2ADBAD0821A; rn = 1; rz = 0; rm = 0; @@ -142515,19 +43531,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -142543,528 +43559,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1861647\n"); + $fwrite(fp,"1864963\n"); end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h8000000000000000; - ans = 64'hBFFFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1862261\n"); - end - xrf = 64'h3FFE000000000100; - y = 64'h0000004007FFFFFE; - zrf = 64'h4000000000000001; - ans = 64'h4000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1862875\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hBFE0000000000001; - zrf = 64'h403FFFFFFC000080; - ans = 64'h403DFFFFFC000080; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1863489\n"); - end - xrf = 64'h417063B4BEBF8A2B; - y = 64'h7FDFFFFFFFFFF004; - zrf = 64'hB990040080000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1864103\n"); - end - xrf = 64'hB7F8BB8D71BC61CF; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1864717\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hC1EFFFFBFDFFFFFF; - zrf = 64'hC3E00010003FFFFE; - ans = 64'hC3E0001000BFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1865331\n"); - end - xrf = 64'hBFDFFFFFFFFDFFFF; - y = 64'hBFF0000000000000; - zrf = 64'hBFCFFFFE7FFFFFFF; - ans = 64'h3FD00000BFFE0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1865945\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hBFB000000FFEFFFF; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1866559\n"); - end - xrf = 64'hC15FFFFF7FFFFFBF; - y = 64'h3FDFFFFFFFFE0004; - zrf = 64'h11EFDFFFFFFF7FFF; - ans = 64'hC14FFFFF7FFDFFC3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1867173\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1867787\n"); - end - xrf = 64'hCF8FFFBFFFFFFFEF; - y = 64'h3F3A0774EB65EC56; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'hCEDA0740DC7C157C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1868401\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; + x = 64'h400FFFFFFFFFFFFF; y = 64'hC000000000000000; - zrf = 64'hB8AB26A99C3445EA; + z = 64'h3CAFFFFFFFFFFFFF; ans = 64'hC01FFFFFFFFFFFFF; rn = 1; rz = 0; @@ -143079,19 +43578,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -143107,12 +43606,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1869015\n"); + $fwrite(fp,"1866977\n"); end - xrf = 64'h3DF851C97AE489ED; - y = 64'h406F7FFFEFFFFFFF; - zrf = 64'h80202003FFFFFFFF; - ans = 64'h3E77F08248D01307; + x = 64'h4050000090000000; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h40BFFFFFFFFFBFFE; + ans = 64'h40BEFFFFF6FFBFFE; rn = 1; rz = 0; rm = 0; @@ -143126,19 +43625,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -143154,12 +43653,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1869629\n"); + $fwrite(fp,"1868991\n"); end - xrf = 64'hC3C0001EFFFFFFFF; - y = 64'hC000000000000001; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h43D0001F00000000; + x = 64'h400FFFFFFF7FFFF7; + y = 64'h402FFFFFFE002000; + z = 64'h47EC7E6897273689; + ans = 64'h47EC7E6897273689; rn = 1; rz = 0; rm = 0; @@ -143173,19 +43672,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -143201,12 +43700,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1870243\n"); + $fwrite(fp,"1871005\n"); end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h401D57E3BE3A6EEF; - zrf = 64'hBFEFFFFFE001FFFF; - ans = 64'h403C57E3BF3A5EEE; + x = 64'h400FFFFFFFFFFFFF; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hC0407FFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -143220,19 +43719,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -143248,435 +43747,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1870857\n"); + $fwrite(fp,"1873019\n"); end - xrf = 64'hB20F9FFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h3FFFFFDFFFFDFFFE; - ans = 64'h3FFFFFDFFFFDFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1871471\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hC00FFFFFBFFFFF7F; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC350000000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1872085\n"); - end - xrf = 64'hBFEFFF9FFFFFFFFE; - y = 64'hA62000003FFFF000; - zrf = 64'h47EFE0007FFFFFFF; - ans = 64'h47EFE0007FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1872699\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hC010000000000001; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1873313\n"); - end - xrf = 64'hC010000003FBFFFE; - y = 64'h403FFFFFFF0007FF; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'hC05FC00006F807FB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1873927\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hC8DF00000001FFFF; - ans = 64'hC8DF00000001FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1874541\n"); - end - xrf = 64'hC297CC5006358D3A; - y = 64'hC08AE04A81A830FF; - zrf = 64'h7FDFFF6FFFFFFFFF; - ans = 64'h7FDFFF6FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1875155\n"); - end - xrf = 64'h3811FFFFFFFFFFEF; - y = 64'hC340000000000000; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hBB61FFFFFFFFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1875769\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hC030100FFFFFFFFF; - zrf = 64'h3EC0007FFFFFFFFF; - ans = 64'hC050100FF7FFBFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1876383\n"); - end - xrf = 64'h3FE001FFFDFFFFFE; + x = 64'hC0377BBF63A456E8; y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h3DE0020000800000; - ans = 64'hC34001FFFDFFFFFD; + z = 64'hC0BFFFFFFF7FEFFF; + ans = 64'h43977BBF63A45667; rn = 1; rz = 0; rm = 0; @@ -143690,19 +43766,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -143718,12 +43794,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1876997\n"); + $fwrite(fp,"1875033\n"); end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h43CEFFFFFFFFFFFB; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'h43EEFFFFFFFFFFFA; + x = 64'h7FEFFF7C00000000; + y = 64'h407007DFFFFFFFFF; + z = 64'hC340000800003FFF; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -143737,19 +43813,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -143765,247 +43841,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1877611\n"); + $fwrite(fp,"1877047\n"); end - xrf = 64'hFFF0000400000800; - y = 64'h41D4297AAC5A616A; - zrf = 64'h403FFFFFF003FFFE; - ans = 64'hFFF8000400000800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1878225\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hFFE0000000000000; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1878839\n"); - end - xrf = 64'h0000000FFFFFF800; - y = 64'h0740000001000000; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1879453\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hFFE0000000000001; - zrf = 64'hBE4F470F822B383A; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1880067\n"); - end - xrf = 64'hC3D4000FFFFFFFFF; - y = 64'hC800000000003FFC; - zrf = 64'h3EF3FFFFFF7FFFFF; - ans = 64'h4BE4001000004FFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1880681\n"); - end - xrf = 64'h00003FEFFFFFFFFF; + x = 64'h400FFFFFFFFFFFFF; y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h8000000000000000; - ans = 64'hBFAFF7FFFFFFFF7E; + z = 64'h4340000000000000; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -144019,19 +43860,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -144047,58 +43888,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1881295\n"); + $fwrite(fp,"1879061\n"); end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h3FCFFFFFFBFFFF7F; - zrf = 64'h58B4207C1CD84EB1; - ans = 64'h58B4207C1CD84EB1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1881909\n"); - end - xrf = 64'h802EA50D4C6B8C19; + x = 64'h8D7D390A1C93061B; y = 64'hFFF0000000000001; - zrf = 64'hBCAFAF3CE171A7BD; + z = 64'h912FF83FFFFFFFFE; ans = 64'hFFF8000000000001; rn = 1; rz = 0; @@ -144113,19 +43907,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -144141,12 +43935,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1882523\n"); + $fwrite(fp,"1881075\n"); end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'h47FFFFFFC0000010; - zrf = 64'hC010000000000000; - ans = 64'h481FFFFFC000000F; + x = 64'hFFF0200003FFFFFE; + y = 64'h406B558929B9440F; + z = 64'h38101000FFFFFFFF; + ans = 64'hFFF8200003FFFFFE; rn = 1; rz = 0; rm = 0; @@ -144160,19 +43954,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -144188,58 +43982,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1883137\n"); + $fwrite(fp,"1883089\n"); end - xrf = 64'h37A0020000080000; - y = 64'h4CEFFFFFFFFFFFAE; - zrf = 64'hFFF010003FFFFFFF; - ans = 64'hFFF810003FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1883751\n"); - end - xrf = 64'h400FFFFFFFFFFFFF; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h4340000000000000; + x = 64'h400FFFFFFFFFFFFE; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -144254,19 +44001,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -144282,12 +44029,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1884365\n"); + $fwrite(fp,"1885103\n"); end - xrf = 64'h2943FFFFF8000000; - y = 64'hC7F0000003FEFFFF; - zrf = 64'h3FD0000000000001; - ans = 64'h3FD0000000000001; + x = 64'h7FFD52F603F067DD; + y = 64'h0010000000000001; + z = 64'hDCA8000000001FFF; + ans = 64'h7FFD52F603F067DD; rn = 1; rz = 0; rm = 0; @@ -144301,19 +44048,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -144329,12 +44076,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1884979\n"); + $fwrite(fp,"1887117\n"); end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h0000000000000000; - zrf = 64'h3F80800000000000; - ans = 64'h3F80800000000000; + x = 64'h3A10800004000000; + y = 64'h800F800100000000; + z = 64'hBD7FFFFFFDFFFFC0; + ans = 64'hBD7FFFFFFDFFFFC0; rn = 1; rz = 0; rm = 0; @@ -144348,19 +44095,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -144376,576 +44123,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1885593\n"); + $fwrite(fp,"1889131\n"); end - xrf = 64'hFFFFFFFFFF000007; - y = 64'hB7FFE00000000000; - zrf = 64'hBFF00007FFFFBFFF; - ans = 64'hFFFFFFFFFF000007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1886207\n"); - end - xrf = 64'h413EFFFFFFFFEFFE; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1886821\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h4013531A0FBE0E92; - zrf = 64'hFFEE5ACB0C27A0DC; - ans = 64'hFFEE5ACB0C27A0DC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1887435\n"); - end - xrf = 64'h2A00000200001FFE; - y = 64'h0010000000000000; - zrf = 64'h3FEFFFFEFFFDFFFE; - ans = 64'h3FEFFFFEFFFDFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1888049\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hC1C1FFFFFFFFFC00; - zrf = 64'hC000000000000001; - ans = 64'hC1E20000003FFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1888663\n"); - end - xrf = 64'h51A66E092B01479D; - y = 64'h3FCFFFFFFFFFFFBF; - zrf = 64'hC35FFFBFFFFFFFBE; - ans = 64'h51866E092B01476F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1889277\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h4010000000000001; - ans = 64'h4010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1889891\n"); - end - xrf = 64'h43EFFFFFFEFFFF7E; - y = 64'hB7FFFFFFFFFFFFF1; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFC0000001FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1890505\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h400FC00000000080; - ans = 64'h400FC00000000080; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1891119\n"); - end - xrf = 64'h43D00101FFFFFFFF; - y = 64'hBFEFFFFFFFFEFFFE; - zrf = 64'h40D2B76E9D285754; - ans = 64'hC3D00101FFFF7FE3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1891733\n"); - end - xrf = 64'hBFFFFFFFFFFFEFFD; - y = 64'h3CA0000000000001; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1892347\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hC3F0040000010000; - zrf = 64'hC7F0002010000000; - ans = 64'hC7F0002010000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1892961\n"); - end - xrf = 64'h9510000000000000; + x = 64'h400FFFFFFFFFFFFE; y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hDD7FFFFFFFFFF007; - ans = 64'hDD7FFFFFFFFFF007; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h3CC7FFFFFFFFFFFD; rn = 1; rz = 0; rm = 0; @@ -144959,19 +44142,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -144987,105 +44170,105 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1893575\n"); + $fwrite(fp,"1891145\n"); end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h42F00400000001FE; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'h43100400000001F5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1894189\n"); - end - xrf = 64'h403FFFFFFFFFC3FE; - y = 64'hFFF0000000003FF0; - zrf = 64'hE96D57E9AF40FC9D; - ans = 64'hFFF8000000003FF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1894803\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; + x = 64'h3FF0000007C00000; y = 64'h3FD0000000000001; - zrf = 64'h400FFFFFFFFFFFFF; + z = 64'hC02FFFFFFFFF3FFF; + ans = 64'hC02F7FFFFFC13FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1893159\n"); + end + x = 64'h1D9BEFFFFFFFFFFE; + y = 64'h8000800000000800; + z = 64'hFFE208A662F4A6B2; + ans = 64'hFFE208A662F4A6B2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1895173\n"); + end + x = 64'h400FFFFFFFFFFFFE; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h3FF0000000000001; ans = 64'h4013FFFFFFFFFFFF; rn = 1; rz = 0; @@ -145100,19 +44283,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -145128,388 +44311,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1895417\n"); + $fwrite(fp,"1897187\n"); end - xrf = 64'hBFC000DFFFFFFFFE; - y = 64'hBFF1FFFFFF800000; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h3FC200FBFF7FF8FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1896031\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h3F03FFFBFFFFFFFF; - ans = 64'h40000013FFFBFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1896645\n"); - end - xrf = 64'h4020000FFFDFFFFE; - y = 64'h7FFFFFFFFBFFFFFC; - zrf = 64'h002FFEFFDFFFFFFF; - ans = 64'h7FFFFFFFFBFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1897259\n"); - end - xrf = 64'hBEBEB67F33381F86; - y = 64'h3FE0000000000000; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1897873\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hC3D000000003DFFE; - zrf = 64'hC07FFFFFFFFFBFF7; - ans = 64'hC3F000000003DFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1898487\n"); - end - xrf = 64'h3FCF000400000000; - y = 64'h3FE0000000000001; - zrf = 64'hC00E1F43407F411C; - ans = 64'hC00D2743207F411C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1899101\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h4030000007EFFFFF; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'h404F80000FDFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1899715\n"); - end - xrf = 64'h434E104364E5057E; - y = 64'h43D7FEFFFFFFFFFF; - zrf = 64'h434008000000007F; - ans = 64'h47368B4209909CF5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1900329\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; + x = 64'hBCDFFFFFFFFF7BFE; y = 64'h3FF0000000000000; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h4017FFFFFFFFFFFE; + z = 64'hBE200FFFFFFFFFF6; + ans = 64'hBE201000FFFFFFF6; rn = 1; rz = 0; rm = 0; @@ -145523,19 +44330,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -145551,12 +44358,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1900943\n"); + $fwrite(fp,"1899201\n"); end - xrf = 64'h5DF54479F7781AF7; - y = 64'h4800000101FFFFFF; - zrf = 64'h0010000000000000; - ans = 64'h6605447B4E6849AC; + x = 64'hBFF0007F00000000; + y = 64'h468FFC00000FFFFF; + z = 64'h40040072D2D248CC; + ans = 64'hC68FFCFDE050007E; rn = 1; rz = 0; rm = 0; @@ -145570,19 +44377,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -145598,12 +44405,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1901557\n"); + $fwrite(fp,"1901215\n"); end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h3FF0000000000001; - zrf = 64'hC02FFFFFFFFE3FFF; - ans = 64'hC027FFFFFFFE3FFF; + x = 64'h400FFFFFFFFFFFFE; + y = 64'h4000000000000001; + z = 64'hC340000000000000; + ans = 64'hC33FFFFFFFFFFFF8; rn = 1; rz = 0; rm = 0; @@ -145617,19 +44424,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -145645,388 +44452,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1902171\n"); + $fwrite(fp,"1903229\n"); end - xrf = 64'h38065F9B291FB446; - y = 64'hBC900000007FFFFB; - zrf = 64'h43403FFFFFFFFF7E; - ans = 64'h43403FFFFFFFFF7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1902785\n"); - end - xrf = 64'hC2AB3D1F5ECB8B72; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h4340000000000000; - ans = 64'h433FE4C2E0A13475; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1903399\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h1830100100000000; - zrf = 64'h43F00000001FFEFE; - ans = 64'h43F00000001FFEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1904013\n"); - end - xrf = 64'hC1E0000000000500; - y = 64'h4000000000000000; - zrf = 64'hC030FFFFFFFF7FFE; - ans = 64'hC1F0000001100500; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1904627\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hBFFCEF01E4D5C217; - zrf = 64'hBFE0000000000000; - ans = 64'hC01EEF01E4D5C215; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1905241\n"); - end - xrf = 64'h400D5F58DE8CF296; - y = 64'hBE0F90E6DD0EA8AE; - zrf = 64'hC7FFDF0000000000; - ans = 64'hC7FFDF0000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1905855\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h3FF0000000000000; - ans = 64'h4030FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1906469\n"); - end - xrf = 64'hC33BE1FA91CC8BBC; - y = 64'h3F65E6B30D9F6D97; - zrf = 64'h0000000000000001; - ans = 64'hC2B31550AC96818D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1907083\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; + x = 64'hBCA1000000010000; y = 64'h4010000000000000; - zrf = 64'hBDEF7FEFFFFFFFFF; - ans = 64'h402FFFFFFFFE07FF; + z = 64'h37F087FFFFFFFFFF; + ans = 64'hBCC1000000010000; rn = 1; rz = 0; rm = 0; @@ -146040,19 +44471,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -146068,12 +44499,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1907697\n"); + $fwrite(fp,"1905243\n"); end - xrf = 64'h3EB0000000001DFF; - y = 64'hBFC0DE4738EB51D2; - zrf = 64'h4A0252BE25281E63; - ans = 64'h4A0252BE25281E63; + x = 64'h1200000FFFFFFFEE; + y = 64'h5EE7632438177A2D; + z = 64'hC2B0000003E00000; + ans = 64'hC2B0000003E00000; rn = 1; rz = 0; rm = 0; @@ -146087,19 +44518,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -146115,12 +44546,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1908311\n"); + $fwrite(fp,"1907257\n"); end - xrf = 64'h380FFFFFFFC04000; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h4010000000000001; - ans = 64'h4010000000000001; + x = 64'h400FFFFFFFFFFFFE; + y = 64'h4340000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -146134,19 +44565,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -146162,12 +44593,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1908925\n"); + $fwrite(fp,"1909271\n"); end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hBFBFFFFFFDFFFFFC; - zrf = 64'hC00FBFDFFFFFFFFF; - ans = 64'hC011DFEFFFDFFFFF; + x = 64'h41D004000007FFFF; + y = 64'h7FE0000000000000; + z = 64'hFFE0080000000004; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -146181,19 +44612,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -146209,12 +44640,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1909539\n"); + $fwrite(fp,"1911285\n"); end - xrf = 64'h80000002FFFFFFFE; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hC03FFFFFFFFFFF01; - ans = 64'hC03FFFFFFFFFFF01; + x = 64'hC1D0000007FFFEFF; + y = 64'hC07FFFFFFF03FFFF; + z = 64'hBFDFFFFFFFFE7FFE; + ans = 64'h426000000781EEFE; rn = 1; rz = 0; rm = 0; @@ -146228,19 +44659,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -146256,528 +44687,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1910153\n"); + $fwrite(fp,"1913299\n"); end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hBCADDF0E689DB01C; - zrf = 64'hBFD0000000000001; - ans = 64'hBFD0000000000010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1910767\n"); - end - xrf = 64'h4000000FFFFFFEFF; - y = 64'hBBD00000000023FF; - zrf = 64'hBACFFFFFFF1FFFFF; - ans = 64'hBBE00018000022C6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1911381\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h3FE0000000000001; - ans = 64'h436FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1911995\n"); - end - xrf = 64'h40CF800400000000; - y = 64'h403DD0FF2D97574A; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1912609\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hBFD3FFFFF0000000; - ans = 64'h436FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1913223\n"); - end - xrf = 64'hA93000000FBFFFFE; - y = 64'h383000006FFFFFFF; - zrf = 64'h3F2FFFEFBFFFFFFE; - ans = 64'h3F2FFFEFBFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1913837\n"); - end - xrf = 64'hC340000000000028; - y = 64'h7FE0000000000001; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1914451\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h3FF67E8BCE4F5BD6; - zrf = 64'h3FDFFFFFFFFFFFEE; - ans = 64'h40187E8BCE4F5BD3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1915065\n"); - end - xrf = 64'h39DFFFFFFFFFBEFE; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hA29FFFFFFEFFF7FF; - ans = 64'h79DFFFFFFFFFBEFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1915679\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h3FA00000FFBFFFFF; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h3FC00000FFBFFFF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1916293\n"); - end - xrf = 64'hB9AFFFFFFEFFFFFD; - y = 64'hC03FFFFF7FFFFBFF; - zrf = 64'hC00FFFFFFFFC003E; - ans = 64'hC00FFFFFFFFC003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1916907\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; + x = 64'h400FFFFFFFFFFFFE; y = 64'h7FF0000000000001; - zrf = 64'h3FDFFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; ans = 64'h7FF8000000000001; rn = 1; rz = 0; @@ -146792,19 +44706,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -146820,12 +44734,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1917521\n"); + $fwrite(fp,"1915313\n"); end - xrf = 64'h43F6C523A35243F7; - y = 64'hC7FFFDF7FFFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; + x = 64'hBFE00000040007FE; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h47FB9BC41BFD4FB5; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -146839,19 +44753,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -146867,12 +44781,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1918135\n"); + $fwrite(fp,"1917327\n"); end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h47E0000000007FF7; - ans = 64'h7FFFFFFFFFFFFFFF; + x = 64'hC013A5CD955A8ECA; + y = 64'h3E007FFFFF7FFFFF; + z = 64'h3B0059C22188F0F5; + ans = 64'hBE2442FC016834CE; rn = 1; rz = 0; rm = 0; @@ -146886,19 +44800,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -146914,2455 +44828,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1918749\n"); + $fwrite(fp,"1919341\n"); end - xrf = 64'hBCA003FFFFFFFFFA; - y = 64'hC3F000041FFFFFFF; - zrf = 64'h04EFFFFFFF1FFFFF; - ans = 64'h40A004042107FFF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1919363\n"); - end - xrf = 64'hBFD006FFFFFFFFFE; - y = 64'h8000000000000000; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h3FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1919977\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h381FFFF8FFFFFFFF; - zrf = 64'hBEFFFFFFF7FFDFFF; - ans = 64'hBEFFFFFFF7FFDFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1920591\n"); - end - xrf = 64'hC3DF0BF692B6C42C; - y = 64'h8000000000000001; - zrf = 64'hC137FFFF7FFFFFFF; - ans = 64'hC137FFFF7FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1921205\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h8028F6B357E9B943; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h804CF6B357E9B941; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1921819\n"); - end - xrf = 64'h44AFFFFFFFFFC03E; - y = 64'h49FFFFC000000007; - zrf = 64'hC3FFFF0001FFFFFF; - ans = 64'h4EBFFFBFFFFFC045; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1922433\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; + x = 64'h400FFFFFFFFFFFFE; y = 64'h8010000000000000; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h3CAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1923047\n"); - end - xrf = 64'hC7AFFFFFFFFFFFFE; - y = 64'h76F6258C5D59960D; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE00002C4B18BAB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1923661\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h8010000000000001; - zrf = 64'h5360000005FFFFFF; - ans = 64'h5360000005FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1924275\n"); - end - xrf = 64'h3FF000000007EFFF; - y = 64'hBFCFFFFFFFFFFDF8; - zrf = 64'h002BFEFFFFFFFFFE; - ans = 64'hBFD000000007EEFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1924889\n"); - end - xrf = 64'h3F6CE728121A019E; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h3FF0000000000000; - ans = 64'h3FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1925503\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h4F7000007BFFFFFF; - zrf = 64'h7FEFFBFFFFFFFFFF; - ans = 64'h7FEFFBFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1926117\n"); - end - xrf = 64'hBFDEFFFFFFFEFFFF; - y = 64'hBCA0000000000000; - zrf = 64'hC7E0000001FF0000; - ans = 64'hC7E0000001FF0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1926731\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h422FFFFFFE000FFF; - zrf = 64'h8010000000000000; - ans = 64'h424FFFFFFE000FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1927345\n"); - end - xrf = 64'h801004FFFFFFFFFF; - y = 64'hC0109335F5BD73BA; - zrf = 64'hC01624D57E096811; - ans = 64'hC01624D57E096811; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1927959\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h3CA0000000000000; - ans = 64'hBCCBFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1928573\n"); - end - xrf = 64'h0000E00000000000; - y = 64'h38020000FFFFFFFF; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1929187\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hBFD0000000000000; - zrf = 64'h41FA150B29B47F8E; - ans = 64'h41FA150B29A47F8E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1929801\n"); - end - xrf = 64'h401D1E0FEB280043; - y = 64'h41F00002000003FF; - zrf = 64'h3CA3E11D80E9DCED; - ans = 64'h421D1E138EEA04EE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1930415\n"); - end - xrf = 64'hBF2FFFFFFFFFFE7F; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h3FE0000000000001; - ans = 64'h3FE0010000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1931029\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hB81F000040000000; - zrf = 64'hE5700000200000FF; - ans = 64'hE5700000200000FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1931643\n"); - end - xrf = 64'hC80FF800000001FF; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h801FFFFF7DFFFFFE; - ans = 64'h47FFF800000001FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1932257\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hC0203DFFFFFFFFFE; - zrf = 64'h8000000000000001; - ans = 64'hC0403DFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1932871\n"); - end - xrf = 64'h41EFFFE00001FFFF; - y = 64'h3FFE631C2D8E143B; - zrf = 64'hD771DCDE9F9BCCFF; - ans = 64'hD771DCDE9F9BCCFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1933485\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h0010000000000001; - ans = 64'hC00FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1934099\n"); - end - xrf = 64'hF55000017FFFFFFF; - y = 64'hB34000000000005F; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'h68A000018000005E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1934713\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h47E0000000003DFE; - ans = 64'h47E0000000003DFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1935327\n"); - end - xrf = 64'hC1FFFFFEFF000000; - y = 64'hBF2FFFE00000001E; - zrf = 64'h3BC6EBA2A1E6E450; - ans = 64'h413FFFDEFF01011E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1935941\n"); - end - xrf = 64'h469FFF7FFDFFFFFE; - y = 64'hBFF0000000000001; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'hC69FFF7FFE000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1936555\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hC273FFFFEFFFFFFF; - zrf = 64'h802000000000003B; - ans = 64'hC293FFFFEFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1937169\n"); - end - xrf = 64'h43F0003FFDFFFFFE; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'hC1E0004001FFFFFE; - ans = 64'hC400003FFE04000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1937783\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h3F8F00001FFFFFFF; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1938397\n"); - end - xrf = 64'h3B90004000007FFF; - y = 64'h3800AF970246D475; - zrf = 64'h402FFFFFFFFF7FFF; - ans = 64'h402FFFFFFFFF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1939011\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hC000000000000001; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hC020000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1939625\n"); - end - xrf = 64'hC1E007FFFFFFFFFB; - y = 64'hBA8FFFFFFFFFB7FE; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1940239\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h37F001FFFFFFC000; - ans = 64'hC02FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1940853\n"); - end - xrf = 64'hBF78000000001FFF; - y = 64'hC02FFFFFFF002000; - zrf = 64'h3DE0003FFFFFFFDF; - ans = 64'h3FB7FFFFFFC039FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1941467\n"); - end - xrf = 64'hB7FDFFFEFFFFFFFF; - y = 64'hC010000000000000; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h3CAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1942081\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hBFD000000007FEFF; - zrf = 64'hC7F0027FFFFFFFFE; - ans = 64'hC7F0027FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1942695\n"); - end - xrf = 64'h3AA04BBDD77BA617; - y = 64'hC010000000000001; - zrf = 64'hC63FFFC080000000; - ans = 64'hC63FFFC080000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1943309\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hBFDD72EABA1C3A92; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1943923\n"); - end - xrf = 64'hC1C0000800000000; - y = 64'h394CF5E001AE5770; - zrf = 64'h3F995E945329308C; - ans = 64'h3F995E945329308C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1944537\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1945151\n"); - end - xrf = 64'hC80FFFFFFFFF8001; - y = 64'hC08E5FDC6EBD366B; - zrf = 64'hC000000000000000; - ans = 64'h48AE5FDC6EBCBCED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1945765\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hC340000000000001; - zrf = 64'hC00C0A216E3AA7B1; - ans = 64'hC360000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1946379\n"); - end - xrf = 64'hBE044E11C9371D80; - y = 64'hFFDFFFDFFFFFEFFE; - zrf = 64'h3D90080000001FFF; - ans = 64'h7DF44DFD7B254A21; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1946993\n"); - end - xrf = 64'h3FBF7FFFFFFFEFFF; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h3CA0000000000000; - ans = 64'hC31F7FFFFFFFEFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1947607\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hBFB07DFFFFFFFFFE; - zrf = 64'h47FFFFFFC000007E; - ans = 64'h47FFFFFFC000007E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1948221\n"); - end - xrf = 64'hA62FFFFFFFFE7FFF; - y = 64'hFFE0000000000000; - zrf = 64'h3AFADEEE30BF7D81; - ans = 64'h661FFFFFFFFE7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1948835\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h9550004002000000; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1949449\n"); - end - xrf = 64'hFFD0FFF7FFFFFFFF; - y = 64'hC0000F0000000000; - zrf = 64'hC3D0002000000007; - ans = 64'h7FE10FE7F87FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1950063\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1950677\n"); - end - xrf = 64'h37E0040000008000; - y = 64'hBE754C8CB9F3E700; - zrf = 64'hBFF0000000000001; + z = 64'hBFF0000000000001; ans = 64'hBFF0000000000001; rn = 1; rz = 0; @@ -149377,19 +44847,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -149405,12 +44875,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1951291\n"); + $fwrite(fp,"1921355\n"); end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'hFFF0000000000000; - zrf = 64'h47F00000000021FF; - ans = 64'hFFF0000000000000; + x = 64'hC02FFBFFFFFFFBFF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hC7EFF7FFFBFFFFFF; + ans = 64'hC7EFF7FFFBFFFFFF; rn = 1; rz = 0; rm = 0; @@ -149424,19 +44894,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -149452,12 +44922,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1951905\n"); + $fwrite(fp,"1923369\n"); end - xrf = 64'hBF2CF0D56A2750C2; - y = 64'h40F00FFFF0000000; - zrf = 64'h002C00000000FFFF; - ans = 64'hC02D0DC622A0A2A9; + x = 64'h002FFFFF83FFFFFF; + y = 64'hC3E401FFFFFFFFFE; + z = 64'hC008DA6B71896C94; + ans = 64'hC008DA6B71896C94; rn = 1; rz = 0; rm = 0; @@ -149471,19 +44941,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -149499,33428 +44969,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1952519\n"); + $fwrite(fp,"1925383\n"); end - xrf = 64'hBC5FFFFFF8003FFF; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h0010000000000001; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1953133\n"); - end - xrf = 64'h400FFFFFFFFFFFFE; - y = 64'h41E00FFFFFFFFFFE; - zrf = 64'hB57FFFFE00000007; - ans = 64'h42000FFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1953747\n"); - end - xrf = 64'h402E953198585D54; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'hC34CD17866F2D756; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1954361\n"); - end - xrf = 64'h4010000000000000; - y = 64'h41F00000FFFFFF00; - zrf = 64'h4340000000000001; - ans = 64'h4340000200002001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1954975\n"); - end - xrf = 64'hC010472174A39022; - y = 64'h9B200000001FFF7F; - zrf = 64'h41F0000080000001; - ans = 64'h41F0000080000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1955589\n"); - end - xrf = 64'h4010000000000000; - y = 64'h0000000000000001; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1956203\n"); - end - xrf = 64'hC1FFFFFFFFC0000F; - y = 64'h41E4000000000007; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hC3F3FFFFFFD80010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1956817\n"); - end - xrf = 64'h4010000000000000; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hC020004000000001; - ans = 64'hC020004000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1957431\n"); - end - xrf = 64'h7FDFFFEFFFFFBFFF; - y = 64'h37EFFFFF7FFF7FFF; - zrf = 64'h42F000000200FFFF; - ans = 64'h77DFFFEF7FFF7FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1958045\n"); - end - xrf = 64'h48008001FFFFFFFF; - y = 64'h0010000000000001; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h0820800200000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1958659\n"); - end - xrf = 64'h4010000000000000; - y = 64'h40468E0D5311E76B; - zrf = 64'h7FD8AF397CA73FA4; - ans = 64'h7FD8AF397CA73FA4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1959273\n"); - end - xrf = 64'hC7E3D9A5109F2CE8; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hE52E363441B31C17; - ans = 64'hE52E363441B31C17; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1959887\n"); - end - xrf = 64'h4010000000000000; - y = 64'h49CF80000000007E; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h49EF80000000007E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1960501\n"); - end - xrf = 64'h3F807FFFEFFFFFFE; - y = 64'hBFD000077FFFFFFF; - zrf = 64'hC362000010000000; - ans = 64'hC362000010000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1961115\n"); - end - xrf = 64'h4010000000000000; - y = 64'h3CA0000000000000; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1961729\n"); - end - xrf = 64'h3FB003DFFFFFFFFF; - y = 64'h06281763EC9DF0B9; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1962343\n"); - end - xrf = 64'h4010000000000000; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h7FF0020000008000; - ans = 64'h7FF8020000008000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1962957\n"); - end - xrf = 64'hBFDFFC0003FFFFFE; - y = 64'h39704000001FFFFE; - zrf = 64'hC3CFFFFFFFFFF806; - ans = 64'hC3CFFFFFFFFFF806; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1963571\n"); - end - xrf = 64'hC03000007C000000; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1964185\n"); - end - xrf = 64'h4010000000000000; - y = 64'h3FD000000000020F; - zrf = 64'hC054CD982D004994; - ans = 64'hC0548D982D00498C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1964799\n"); - end - xrf = 64'hBD27E1AD5D2B709B; - y = 64'h3FD0000000000001; - zrf = 64'hC7F0000000002000; - ans = 64'hC7F0000000002000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1965413\n"); - end - xrf = 64'h4010000000000000; - y = 64'hFFDFE0000FFFFFFF; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1966027\n"); - end - xrf = 64'h40137F75FC3315AF; - y = 64'hBFD080000001FFFF; - zrf = 64'hBCAFBFFFFFFFFFFF; - ans = 64'hBFF41B71AC171E4B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1966641\n"); - end - xrf = 64'h4010000000000000; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC017FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1967255\n"); - end - xrf = 64'hBFC000000080FFFF; - y = 64'h7FDFFFFF7FFFFEFE; - zrf = 64'hBFD0000000000000; - ans = 64'hFFAFFFFF8101FEF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1967869\n"); - end - xrf = 64'h4010000000000000; - y = 64'h3FE0000000000001; - zrf = 64'hC7E00000407FFFFF; - ans = 64'hC7E00000407FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1968483\n"); - end - xrf = 64'hBFAC2BA02D28C36A; - y = 64'h800010000000FFFE; - zrf = 64'h43C0000020004000; - ans = 64'h43C0000020004000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1969097\n"); - end - xrf = 64'h437A753665F4C413; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1969711\n"); - end - xrf = 64'h4010000000000000; - y = 64'h7FEFFFF801FFFFFF; - zrf = 64'h4035D7EF299EB91C; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1970325\n"); - end - xrf = 64'hC8007FFFFFFFFFF7; - y = 64'h3FF0000000000000; - zrf = 64'h41E0000200000FFE; - ans = 64'hC8007FFFFFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1970939\n"); - end - xrf = 64'h4010000000000000; - y = 64'h37E00000001FFDFE; - zrf = 64'h4000000000000000; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1971553\n"); - end - xrf = 64'h800BFFFBFFFFFFFF; - y = 64'h452FFBFFDFFFFFFE; - zrf = 64'h1A5000000001FF80; - ans = 64'h1A5000000001FF80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1972167\n"); - end - xrf = 64'h4010000000000000; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hC010000000000000; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1972781\n"); - end - xrf = 64'hC480000100000001; - y = 64'hC06FFFFFE0100000; - zrf = 64'hBCA0000000000001; - ans = 64'h45000000F007FF01; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1973395\n"); - end - xrf = 64'h4010000000000000; - y = 64'h4000000000000000; - zrf = 64'hC01FFFFFFFC007FF; - ans = 64'h3E2FFC0080000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1974009\n"); - end - xrf = 64'hC16FFFFFDFFFFF7E; - y = 64'h3DB1201419E58E36; - zrf = 64'h4E1FDFFFFFFFFFFC; - ans = 64'h4E1FDFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1974623\n"); - end - xrf = 64'hDF50011FFFFFFFFE; - y = 64'h4000000000000001; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1975237\n"); - end - xrf = 64'h4010000000000000; - y = 64'h47E003FFFFFFFFBF; - zrf = 64'hC01FFF0000001FFF; - ans = 64'h480003FFFFFFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1975851\n"); - end - xrf = 64'h402862D346BAA1CA; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h411FFFFFFFFBFEFF; - ans = 64'h412000618B4B1A6A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1976465\n"); - end - xrf = 64'h4010000000000000; - y = 64'h380FFFFFEFFFF7FE; - zrf = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1977079\n"); - end - xrf = 64'hBEFEEFFFFFFFFFFF; - y = 64'h7FF000003BFFFFFE; - zrf = 64'h40CF7B1D7B973928; - ans = 64'h7FF800003BFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1977693\n"); - end - xrf = 64'h4010000000000000; - y = 64'h4010000000000001; - zrf = 64'hC000000000000001; - ans = 64'h402C000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1978307\n"); - end - xrf = 64'h3FB2000000000001; - y = 64'hC035E13C67919490; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'hBFF89D63F483C723; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1978921\n"); - end - xrf = 64'h4010000000000000; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h3FE92BD129459E10; - ans = 64'h404064AF44A51677; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1979535\n"); - end - xrf = 64'h3CA1FDFFFFFFFFFF; - y = 64'hB9FC538ED462F3E6; - zrf = 64'h480FFC000000003E; - ans = 64'h480FFC000000003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1980149\n"); - end - xrf = 64'hBFB0E2E2A19DE3CA; - y = 64'h4340000000000000; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC3508717150CEF1E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1980763\n"); - end - xrf = 64'h4010000000000000; - y = 64'hB80FFFF80000000F; - zrf = 64'hC1CFFFFFFFFFFE08; - ans = 64'hC1CFFFFFFFFFFE08; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1981377\n"); - end - xrf = 64'h3FBFFFFFFFFFFFC2; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h462FFFC0007FFFFF; - ans = 64'h462FFFC00080000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1981991\n"); - end - xrf = 64'h4010000000000000; - y = 64'hC80FE0001FFFFFFF; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'hC82FE0001FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1982605\n"); - end - xrf = 64'h37F0001FFFFC0000; - y = 64'hC000000800000020; - zrf = 64'h3FBFFFF800002000; - ans = 64'h3FBFFFF800002000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1983219\n"); - end - xrf = 64'h4010000000000000; - y = 64'h7FE0000000000000; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1983833\n"); - end - xrf = 64'h41E8BF333C53DC11; - y = 64'hBFFFE02000000000; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hC1F8A68CC84AC489; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1984447\n"); - end - xrf = 64'h4010000000000000; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hC3FFFBFFF8000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1985061\n"); - end - xrf = 64'h3FC002FFFFFFFFFE; - y = 64'h480FFFFFFFFEFFFE; - zrf = 64'h884FDFFFFFFFFFFF; - ans = 64'h47E002FFFFFF7FE5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1985675\n"); - end - xrf = 64'hC150000001FFFFEF; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1986289\n"); - end - xrf = 64'h4010000000000000; - y = 64'h3FDFE0000000000F; - zrf = 64'h381000800007FFFF; - ans = 64'h3FFFE0000000000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1986903\n"); - end - xrf = 64'h61CFFFC000007FFF; - y = 64'h7FF0000000000001; - zrf = 64'h37EF040000000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1987517\n"); - end - xrf = 64'h4010000000000000; - y = 64'hBFBFFFFFFC00000F; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3E2FFFFF78000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1988131\n"); - end - xrf = 64'hB815F9F97A094A5C; - y = 64'h43FEFFFFFFF7FFFF; - zrf = 64'h43CFFFFFFF7FFFFD; - ans = 64'h43CFFFFFFF7FFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1988745\n"); - end - xrf = 64'h4010000000000000; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'hBFEFFFFFFFFFFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1989359\n"); - end - xrf = 64'h800000000003FFFE; - y = 64'h578284B14DFCC6E4; - zrf = 64'h8000000000000000; - ans = 64'h958284A80BA41FE6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1989973\n"); - end - xrf = 64'h4010000000000000; - y = 64'h8000000000000001; - zrf = 64'h3D00001000000020; - ans = 64'h3D00001000000020; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1990587\n"); - end - xrf = 64'h002FFC0000001FFE; - y = 64'h4820040000000003; - zrf = 64'h401E4B4C703F7797; - ans = 64'h401E4B4C703F7797; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1991201\n"); - end - xrf = 64'hFFF090069ECD0983; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hC010000000000000; - ans = 64'hFFF890069ECD0983; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1991815\n"); - end - xrf = 64'h4010000000000000; - y = 64'h802FFE0100000000; - zrf = 64'h266FFFFFFBC00000; - ans = 64'h266FFFFFFBC00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1992429\n"); - end - xrf = 64'h2F9A42B08462C128; - y = 64'h8010000000000000; - zrf = 64'hC800004001FFFFFF; - ans = 64'hC800004001FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1993043\n"); - end - xrf = 64'h4010000000000000; - y = 64'h7FDFFFFBFEFFFFFF; - zrf = 64'h3FD0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1993657\n"); - end - xrf = 64'hC27BDFFFFFFFFFFF; - y = 64'hBFD415B58CED442A; - zrf = 64'hC3F657E5A2C1DB31; - ans = 64'hC3F657E59A02669E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1994271\n"); - end - xrf = 64'h4010000000000000; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1994885\n"); - end - xrf = 64'h801000000000005F; - y = 64'h3FEE0000000000FF; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1995499\n"); - end - xrf = 64'h4010000000000000; - y = 64'hBCA0000000000000; - zrf = 64'h40D0001010000000; - ans = 64'h40D0001010000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1996113\n"); - end - xrf = 64'hC7A95C960A5C58BF; - y = 64'h404000FFFFFDFFFF; - zrf = 64'hC7F58C9EBE2500D7; - ans = 64'hC807756548EF69E4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1996727\n"); - end - xrf = 64'h403FFFC003FFFFFE; - y = 64'hBCA0000000000001; - zrf = 64'hC000000000000001; - ans = 64'hC000000000000009; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1997341\n"); - end - xrf = 64'h4010000000000000; - y = 64'h801020000FFFFFFF; - zrf = 64'hBFE00000081FFFFF; - ans = 64'hBFE00000081FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1997955\n"); - end - xrf = 64'h8010000017FFFFFE; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h37EEFFFFFFFFFFFA; - ans = 64'h37EEFFFFFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1998569\n"); - end - xrf = 64'h4010000000000000; - y = 64'hC3F8AC97F983EA17; - zrf = 64'h3CA0000000000001; - ans = 64'hC418AC97F983EA17; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1999183\n"); - end - xrf = 64'h3F6FFDFFFFFFFF7F; - y = 64'hC03A51B5C97AF6EB; - zrf = 64'hC000000010000FFF; - ans = 64'hC000D280957102F6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"1999797\n"); - end - xrf = 64'h4010000000000000; - y = 64'hBFD0000000000001; - zrf = 64'hBFD0000000000001; - ans = 64'hBFF4000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2000411\n"); - end - xrf = 64'h3F4FFFBFFFFFFFFF; - y = 64'hBFC00001FFFFFFFF; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2001025\n"); - end - xrf = 64'h4010000000000000; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h3FB0003FFFFFFFDF; - ans = 64'hBFFEFFFC00000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2001639\n"); - end - xrf = 64'h67CC0B0B8FFD1579; - y = 64'hC1F9F508DABEAAB9; - zrf = 64'h37FFFFFFFFFFE00F; - ans = 64'hE9D6BF5D5B795C69; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2002253\n"); - end - xrf = 64'hC3E40000001FFFFE; - y = 64'hBFE0000000000000; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'h43D40000001FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2002867\n"); - end - xrf = 64'h4010000000000000; - y = 64'hC91FFFFFFFFFC001; - zrf = 64'hBF8FE00040000000; - ans = 64'hC93FFFFFFFFFC001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2003481\n"); - end - xrf = 64'h338FFFFDFFDFFFFF; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h43E0200800000000; - ans = 64'h43E0200800000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2004095\n"); - end - xrf = 64'h4010000000000000; - y = 64'h3F5FFFFFFFD80000; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h3F7FFFFFFFD80000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2004709\n"); - end - xrf = 64'hE96FFFFEFF7FFFFF; - y = 64'h3FF1FFFFBFFFFFFE; - zrf = 64'hBFCFFFF800000040; - ans = 64'hE971FFFF2FB801FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2005323\n"); - end - xrf = 64'h4010000000000000; - y = 64'hBFF0000000000000; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2005937\n"); - end - xrf = 64'h3D200007FFFFFFEF; - y = 64'hC00876C4B616918C; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2006551\n"); - end - xrf = 64'h4010000000000000; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'hCFA4200000000000; - ans = 64'hCFA4200000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2007165\n"); - end - xrf = 64'hA60FC80000000000; - y = 64'hFFE107FFFFFFFFFF; - zrf = 64'hFFDFFFC800000000; - ans = 64'hFFDFFFC800000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2007779\n"); - end - xrf = 64'hC180001FFFFFE000; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'h4190001FFBFFDFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2008393\n"); - end - xrf = 64'h4010000000000000; - y = 64'h401389E4A0774013; - zrf = 64'h47F00003FFFDFFFF; - ans = 64'h47F00003FFFDFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2009007\n"); - end - xrf = 64'hB7E4A4C01BE0366D; - y = 64'hC000000000000001; - zrf = 64'h4030040000000000; - ans = 64'h4030040000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2009621\n"); - end - xrf = 64'h4010000000000000; - y = 64'h3DD822906B7C1856; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h3DF822906B7C1856; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2010235\n"); - end - xrf = 64'hBF300003FFFFFFFA; - y = 64'h4663B7CF95147D4D; - zrf = 64'hC020000FFFFFDFFF; - ans = 64'hC5A3B7D48308628B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2010849\n"); - end - xrf = 64'h4010000000000000; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'hC02FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2011463\n"); - end - xrf = 64'h480F803FFFFFFFFF; - y = 64'hFFD01FFFFFFFFFC0; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2012077\n"); - end - xrf = 64'h4010000000000000; - y = 64'hC010000000000001; - zrf = 64'hBFAA9630F7FA91E2; - ans = 64'hC0300D4B187BFD4A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2012691\n"); - end - xrf = 64'h46BFFFFFFFFBE000; - y = 64'hFFDFFFFFFFE00020; - zrf = 64'h001D7B4EBB1E2287; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2013305\n"); - end - xrf = 64'hBFDFFFFFFC000400; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hBFE0000000000000; - ans = 64'h400BFFFFFC0003FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2013919\n"); - end - xrf = 64'h4010000000000000; - y = 64'h65E6E9986A054481; - zrf = 64'h3FC0017FFFFFFFFE; - ans = 64'h6606E9986A054481; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2014533\n"); - end - xrf = 64'h400FFFFFFF7BFFFE; - y = 64'hC340000000000000; - zrf = 64'hBFF0800000000010; - ans = 64'hC35FFFFFFF7BFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2015147\n"); - end - xrf = 64'h4010000000000000; - y = 64'hBFDFFFFFFFF02000; - zrf = 64'h0000000000000000; - ans = 64'hBFFFFFFFFFF02000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2015761\n"); - end - xrf = 64'hB8E0004080000000; - y = 64'hC1E007FFFFFFEFFF; - zrf = 64'hC1F04C3464638FD0; - ans = 64'hC1F04C3464638FD0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2016375\n"); - end - xrf = 64'h4010000000000000; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h8010000000000000; - ans = 64'hC36FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2016989\n"); - end - xrf = 64'h2F1F7FF800000000; - y = 64'h3FA5BD663D679381; - zrf = 64'h4010000000000001; - ans = 64'h4010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2017603\n"); - end - xrf = 64'h4010000000000000; - y = 64'hFFE0000000000000; - zrf = 64'hC95FFFEFFFFDFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2018217\n"); - end - xrf = 64'hBFDEFFFFFF000000; - y = 64'h002FFFFFFFFC3FFE; - zrf = 64'h0000002003FFFFFE; - ans = 64'h801EFFDFFAFC5E00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2018831\n"); - end - xrf = 64'h3FC0000000000021; - y = 64'hFFE0000000000001; - zrf = 64'hBFD0000000000001; - ans = 64'hFFB0000000000022; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2019445\n"); - end - xrf = 64'h4010000000000000; - y = 64'h7FD000011FFFFFFE; - zrf = 64'h480A9FA0EAF588F8; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2020059\n"); - end - xrf = 64'h7FFFE00000100000; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'hC05FFFFFFFFFFF0F; - ans = 64'h7FFFE00000100000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2020673\n"); - end - xrf = 64'h4010000000000000; - y = 64'hBFB4E50445E15FFE; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2021287\n"); - end - xrf = 64'hC34FFFFFF80007FE; - y = 64'h43D0047FFFFFFFFF; - zrf = 64'h41C87C353CDA6D3F; - ans = 64'hC730047FFBFEE3FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2021901\n"); - end - xrf = 64'h4010000000000000; - y = 64'hFFF0000000000001; - zrf = 64'h8000000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2022515\n"); - end - xrf = 64'h578E007FFFFFFFFF; - y = 64'hC3CFFE7FFFFFFFFE; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'hDB6DFF17F9FFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2023129\n"); - end - xrf = 64'h4010000000000000; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h7FEFFFFFBFFFFFDE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2023743\n"); - end - xrf = 64'hC34FFF5FFFFFFFFE; - y = 64'hA21403EE84EDAC39; - zrf = 64'hC1EFFFFFEFFFFFFF; - ans = 64'hC1EFFFFFEFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2024357\n"); - end - xrf = 64'hBFDDFFFFFFFFFFF6; - y = 64'h0000000000000000; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2024971\n"); - end - xrf = 64'h4010000000000001; - y = 64'h390400000000FFFE; - zrf = 64'h41CB3043321369C3; - ans = 64'h41CB3043321369C3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2025585\n"); - end - xrf = 64'h37FFFFFFFFFFFFEE; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'hBC600010001FFFFF; - ans = 64'hBC600010001FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2026199\n"); - end - xrf = 64'h4010000000000001; - y = 64'hB7F1000000000002; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2026813\n"); - end - xrf = 64'hFFD3F02B09C09A41; - y = 64'hC031200000000000; - zrf = 64'hC34BB5F53BEB70B5; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2027427\n"); - end - xrf = 64'h4010000000000001; - y = 64'h0010000000000000; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2028041\n"); - end - xrf = 64'h381FFF801FFFFFFF; - y = 64'h43EFFE0007FFFFFE; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h3FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2028655\n"); - end - xrf = 64'h4010000000000001; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hBFDFFF0007FFFFFF; - ans = 64'hBFDFFF0007FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2029269\n"); - end - xrf = 64'h40022DF889E0460E; - y = 64'h480083FFFFFFFFFF; - zrf = 64'hBFE003FFDFFFFFFF; - ans = 64'h4812C3F3CC51C04F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2029883\n"); - end - xrf = 64'h404FFFFFFF00003E; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h007F7FFFFF00003C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2030497\n"); - end - xrf = 64'h4010000000000001; - y = 64'h43D000001EFFFFFF; - zrf = 64'hBA736F94D9A1D3B3; - ans = 64'h43F000001F000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2031111\n"); - end - xrf = 64'h3FD00003FFFFFFEF; - y = 64'h3CA0000000000001; - zrf = 64'h15407FFFFFFFFF80; - ans = 64'h3C800003FFFFFFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2031725\n"); - end - xrf = 64'h4010000000000001; - y = 64'h7FEFFFFF7FFFFEFF; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2032339\n"); - end - xrf = 64'hC78FFFFFFFF7FEFE; - y = 64'hC6C5A9C8AB5EEB18; - zrf = 64'h3F7007FFFFEFFFFF; - ans = 64'h4E65A9C8AB597FF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2032953\n"); - end - xrf = 64'h4010000000000001; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2033567\n"); - end - xrf = 64'h42A000000FFFFF00; - y = 64'hBFD3000000000000; - zrf = 64'h3FF0000000000000; - ans = 64'hC283000012FFF6D0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2034181\n"); - end - xrf = 64'h4010000000000001; - y = 64'h3FD0000000000001; - zrf = 64'hBCAFFFFFDFFFEFFE; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2034795\n"); - end - xrf = 64'h400101E2034348A8; - y = 64'h3800000FFFFFC000; - zrf = 64'h801000000000FFFD; - ans = 64'h381101F3052507E4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2035409\n"); - end - xrf = 64'hC3D73FF233226D60; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h8010000000000000; - ans = 64'hC3C73FF233226D5F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2036023\n"); - end - xrf = 64'h4010000000000001; - y = 64'h4331EBC8B95B9247; - zrf = 64'h001F7FFEFFFFFFFF; - ans = 64'h4351EBC8B95B9248; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2036637\n"); - end - xrf = 64'hBDE82DB0311C0CE4; - y = 64'h3FE0000000000000; - zrf = 64'hB7F0000003FFFFFB; - ans = 64'hBDD82DB0311C0CE4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2037251\n"); - end - xrf = 64'h4010000000000001; - y = 64'h417FE00000002000; - zrf = 64'hC340000000000000; - ans = 64'hC33FFFFFF8080000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2037865\n"); - end - xrf = 64'h4691FFFBFFFFFFFF; - y = 64'h0D0FFFF020000000; - zrf = 64'hC27ABBD29987D6DC; - ans = 64'hC27ABBD29987D6DC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2038479\n"); - end - xrf = 64'h4010000000000001; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2039093\n"); - end - xrf = 64'h43F003FBFFFFFFFE; - y = 64'hBFEFF00000007FFF; - zrf = 64'h3FE0000000000001; - ans = 64'hC3EFF7F40400801B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2039707\n"); - end - xrf = 64'h4010000000000001; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h407FFFE000FFFFFE; - ans = 64'h40801FF0007FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2040321\n"); - end - xrf = 64'h40CCF306BA45AE38; - y = 64'hA6A00000000207FF; - zrf = 64'h7FD1002000000000; - ans = 64'h7FD1002000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2040935\n"); - end - xrf = 64'hBF7FBFFFFFBFFFFE; - y = 64'h3FF0000000000001; - zrf = 64'h8000000000000001; - ans = 64'hBF7FBFFFFFC00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2041549\n"); - end - xrf = 64'h4010000000000001; - y = 64'h402828229504FC88; - zrf = 64'hFFD5A537DFEEA9A8; - ans = 64'hFFD5A537DFEEA9A8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2042163\n"); - end - xrf = 64'h3C1000000000037F; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h2516ADF118D6B0B6; - ans = 64'h3C2000000000037E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2042777\n"); - end - xrf = 64'h4010000000000001; - y = 64'hBF1FBFFFFFFF7FFF; - zrf = 64'hC010000000000001; - ans = 64'hC010007EFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2043391\n"); - end - xrf = 64'hCC50000000000FBF; - y = 64'h3FFFFBFFFEFFFFFE; - zrf = 64'hB7E0008000000006; - ans = 64'hCC5FFBFFFF001F78; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2044005\n"); - end - xrf = 64'h4010000000000001; - y = 64'h4000000000000001; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2044619\n"); - end - xrf = 64'h5EB0734C2E41E43E; - y = 64'hC1F0000000200040; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'hE0B0734C2E62CB18; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2045233\n"); - end - xrf = 64'h4010000000000001; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hCE1000000027FFFF; - ans = 64'hCE1000000027FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2045847\n"); - end - xrf = 64'h802EFFFFFFFFFE00; - y = 64'h41EFF0000000001F; - zrf = 64'hBCEFFC0001FFFFFF; - ans = 64'hBCEFFC0001FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2046461\n"); - end - xrf = 64'h98700000000001BF; - y = 64'h4010000000000000; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2047075\n"); - end - xrf = 64'h4010000000000001; - y = 64'hD3100000FF000000; - zrf = 64'hBF40000000101FFF; - ans = 64'hD3300000FF000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2047689\n"); - end - xrf = 64'h437F000000002000; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h570FFDFFFFFFFBFE; - ans = 64'h570FFDFFFFFFFBFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2048303\n"); - end - xrf = 64'h4010000000000001; - y = 64'hBC6FFFFF80004000; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2048917\n"); - end - xrf = 64'hB81E07FFFFFFFFFF; - y = 64'h3FEC000007FFFFFE; - zrf = 64'h3C6040000000003E; - ans = 64'h3C6040000000003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2049531\n"); - end - xrf = 64'h4010000000000001; - y = 64'h4340000000000000; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h4360000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2050145\n"); - end - xrf = 64'hC0CEF80000000000; - y = 64'h4010000401000000; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'hC0EEF807BFEF8000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2050759\n"); - end - xrf = 64'h4010000000000001; - y = 64'h4340000000000001; - zrf = 64'h3810000000040001; - ans = 64'h4360000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2051373\n"); - end - xrf = 64'h402FFFFFFFF80020; - y = 64'hDC5000FFFFFFFFE0; - zrf = 64'hB428005DA0DF19DC; - ans = 64'hDC9000FFFFFBFFB0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2051987\n"); - end - xrf = 64'hBF809DB40C6850A4; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2052601\n"); - end - xrf = 64'h4010000000000001; - y = 64'h381FFFFFF0080000; - zrf = 64'h7FF7FBFFFFFFFFFF; - ans = 64'h7FFFFBFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2053215\n"); - end - xrf = 64'hBCA01FFFFFFFBFFF; - y = 64'h7FE0000000000000; - zrf = 64'h47EE010000000000; - ans = 64'hFC901FFFFFFFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2053829\n"); - end - xrf = 64'h4010000000000001; - y = 64'h43F10FFFFFFFFFFE; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'h44110FFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2054443\n"); - end - xrf = 64'hC3ACF9C2E5A7EDD3; - y = 64'hBCA0000000000000; - zrf = 64'h3F2000000001FFDE; - ans = 64'h405CF9C4E5A7EDD3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2055057\n"); - end - xrf = 64'h4010000000000001; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2055671\n"); - end - xrf = 64'hFFF0000004003FFE; - y = 64'h6A9FFBFFFFDFFFFF; - zrf = 64'h3CA0000000000000; - ans = 64'hFFF8000004003FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2056285\n"); - end - xrf = 64'h4010000000000001; - y = 64'h7FF0000000000000; - zrf = 64'hC061FFFFFFFFFFFA; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2056899\n"); - end - xrf = 64'h3FD351BAD190EE0E; - y = 64'hFB20103FFFFFFFFF; - zrf = 64'h44FA1AFBC4ECDEF6; - ans = 64'hFB036559D34DC53F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2057513\n"); - end - xrf = 64'h41E000FFFFFFFFF7; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h7FE0000000000000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2058127\n"); - end - xrf = 64'h4010000000000001; - y = 64'h3FF38C1608094E37; - zrf = 64'hB90DFCA930882C14; - ans = 64'h40138C1608094E38; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2058741\n"); - end - xrf = 64'h802FBFF000000000; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h402FFFFFFDFFFF7F; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2059355\n"); - end - xrf = 64'h4010000000000001; - y = 64'h4036F22DF5763FE7; - zrf = 64'hBFF0000000000000; - ans = 64'h4056B22DF5763FE8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2059969\n"); - end - xrf = 64'h3FF6FE2E918FDD2B; - y = 64'hB7E0E00000000000; - zrf = 64'hC02418F02A11FD65; - ans = 64'hC02418F02A11FD65; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2060583\n"); - end - xrf = 64'h4010000000000001; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h4000000000000000; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2061197\n"); - end - xrf = 64'h37EE8DC9DCAE85C1; - y = 64'h002001FFFFFFFFFC; - zrf = 64'h0010000000000001; - ans = 64'h0010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2061811\n"); - end - xrf = 64'h4010000000000001; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h356FFFFFF8800000; - ans = 64'h356FFFFFF8800000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2062425\n"); - end - xrf = 64'h37F0000000005FFE; - y = 64'hB8000005FFFFFFFF; - zrf = 64'h3CE0002004000000; - ans = 64'h3CE0002004000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2063039\n"); - end - xrf = 64'hFFD0000000000000; - y = 64'h8010000000000001; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2063653\n"); - end - xrf = 64'h4010000000000001; - y = 64'hB8100800000003FF; - zrf = 64'hC3E0000004040000; - ans = 64'hC3E0000004040000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2064267\n"); - end - xrf = 64'h43C7FFFBFFFFFFFF; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h401DFFFFFFFFFFEF; - ans = 64'h401DFFFFFFFFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2064881\n"); - end - xrf = 64'h4010000000000001; - y = 64'hB8C0003FFFFFFFFE; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2065495\n"); - end - xrf = 64'hB80000FFFFFFFFF0; - y = 64'h7FF0000800000003; - zrf = 64'h99D7403FC620853D; - ans = 64'h7FF8000800000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2066109\n"); - end - xrf = 64'h4010000000000001; - y = 64'hBCA0000000000001; - zrf = 64'h3FF0000000000001; - ans = 64'h3FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2066723\n"); - end - xrf = 64'hCD872EAD1D5E17B0; - y = 64'hC800001FFFFFDFFF; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h55972EDB7AB8240D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2067337\n"); - end - xrf = 64'h4010000000000001; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h3EA0000002000080; - ans = 64'h3EA0000001800080; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2067951\n"); - end - xrf = 64'h4F300013FFFFFFFF; - y = 64'hC0BFE34666739635; - zrf = 64'h40372CC2C5156BE3; - ans = 64'hCFFFE36E428B9643; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2068565\n"); - end - xrf = 64'hC5DFFFFFFFFBF800; + x = 64'h400FFFFFFFFFFFFE; y = 64'hBFD0000000000000; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h45BFFFFFFFFBF800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2069179\n"); - end - xrf = 64'h4010000000000001; - y = 64'h703FFFFFFFFC0008; - zrf = 64'hBFF0000007FFFFFF; - ans = 64'h705FFFFFFFFC000A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2069793\n"); - end - xrf = 64'h0020010000000003; - y = 64'hBFD0000000000001; - zrf = 64'h41DAD18B4B15E433; - ans = 64'h41DAD18B4B15E433; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2070407\n"); - end - xrf = 64'h4010000000000001; - y = 64'h3FDFFFFBFF000000; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'h3FF7FFFBFF000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2071021\n"); - end - xrf = 64'hB7FFFFAFFFFFFFFF; - y = 64'hBFA0000007FFFBFF; - zrf = 64'hC02FFFFFF8000020; - ans = 64'hC02FFFFFF8000020; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2071635\n"); - end - xrf = 64'h4010000000000001; - y = 64'hBFE0000000000000; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'hBFF0000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2072249\n"); - end - xrf = 64'h4050000FFFFF8000; - y = 64'h3FEFFFFFFFFFFFB7; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2072863\n"); - end - xrf = 64'h4010000000000001; - y = 64'hBFE0000000000001; - zrf = 64'h58B0023FFFFFFFFF; - ans = 64'h58B0023FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2073477\n"); - end - xrf = 64'hC0D00407FFFFFFFF; - y = 64'h44560B21BC8DFFBC; - zrf = 64'h45D000007FFFC000; - ans = 64'h45CFF4F8A83A38FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2074091\n"); - end - xrf = 64'h43CC0000001FFFFF; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'hC3CC0000001FFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2074705\n"); - end - xrf = 64'h4010000000000001; - y = 64'h001FFFFFEFFFFFF7; - zrf = 64'hE5FFFFFFFFFFFFFE; - ans = 64'hE5FFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2075319\n"); - end - xrf = 64'h3FAFFFDFF7FFFFFE; - y = 64'hBFF0000000000000; - zrf = 64'hC1EFFF7FFFDFFFFF; - ans = 64'hC1EFFF7FFFE1FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2075933\n"); - end - xrf = 64'h4010000000000001; - y = 64'h7FEFDFFFFFF80000; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2076547\n"); - end - xrf = 64'h3FCF0000000FFFFF; - y = 64'hC54BFFFFFFF7FFFE; - zrf = 64'h380FFFFFFFFFFC10; - ans = 64'hC52B200000063FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2077161\n"); - end - xrf = 64'h4010000000000001; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'hC01E000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2077775\n"); - end - xrf = 64'hC34000000FFEFFFE; - y = 64'hC000000000000009; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2078389\n"); - end - xrf = 64'h4010000000000001; - y = 64'hC000000000000000; - zrf = 64'hB810000000040400; - ans = 64'hC020000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2079003\n"); - end - xrf = 64'hCCFFFFC0000FFFFE; - y = 64'hC3F11E81095D5E21; - zrf = 64'hBE2FF8000007FFFF; - ans = 64'h51011E5ECC63DAA6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2079617\n"); - end - xrf = 64'hBD4FFFDFDFFFFFFE; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h4000000000000000; - ans = 64'h4000000000000800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2080231\n"); - end - xrf = 64'h4010000000000001; - y = 64'h3FB639FC3EC1E7C8; - zrf = 64'h47F1FFFFFFFFF7FF; - ans = 64'h47F1FFFFFFFFF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2080845\n"); - end - xrf = 64'h37E0000002001FFF; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h41F00007FFFFFFEF; - ans = 64'h41F00007FFFFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2081459\n"); - end - xrf = 64'h4010000000000001; - y = 64'hBFD0000FBFFFFFFF; - zrf = 64'hBCA0000000000000; - ans = 64'hBFF0000FC0000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2082073\n"); - end - xrf = 64'h3CA0000FFFFFFFEE; - y = 64'h0A0FFE0080000000; - zrf = 64'h3FA00000000FFEFF; - ans = 64'h3FA00000000FFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2082687\n"); - end - xrf = 64'h4010000000000001; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h3FD0000000000000; - ans = 64'hC03FC00000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2083301\n"); - end - xrf = 64'hC01EDEE0EE02DDAB; - y = 64'hC02EAF41CE1BC0BD; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2083915\n"); - end - xrf = 64'h4010000000000001; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hC0EFF6FFFFFFFFFF; - ans = 64'hC0EFFAFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2084529\n"); - end - xrf = 64'h406E5774F05A50D8; - y = 64'h002F808000000000; - zrf = 64'h7FF000000200007F; - ans = 64'h7FF800000200007F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2085143\n"); - end - xrf = 64'hC02FFE0000008000; - y = 64'hC340000000000001; - zrf = 64'h3FF0000000000001; - ans = 64'h437FFE0000008002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2085757\n"); - end - xrf = 64'h4010000000000001; - y = 64'h401FFE0001FFFFFF; - zrf = 64'h747A807778879FF0; - ans = 64'h747A807778879FF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2086371\n"); - end - xrf = 64'h800000101FFFFFFE; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hC3E29498223D1003; - ans = 64'hC3E29498223D1003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2086985\n"); - end - xrf = 64'h4010000000000001; - y = 64'h4010000000000407; - zrf = 64'h8010000000000001; - ans = 64'h4030000000000408; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2087599\n"); - end - xrf = 64'hC3D10560432CD7FD; - y = 64'h40700000000007FC; - zrf = 64'hBD23FFFBFFFFFFFE; - ans = 64'hC4510560432CE07B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2088213\n"); - end - xrf = 64'h4010000000000001; - y = 64'hFFE0000000000001; - zrf = 64'h3CA0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2088827\n"); - end - xrf = 64'hBF4003FFFFDFFFFF; - y = 64'h415000003FFFF7FF; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC350000000000200; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2089441\n"); - end - xrf = 64'h4010000000000001; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hB7FFFE00000003FF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2090055\n"); - end - xrf = 64'h43D00000002FFFFF; - y = 64'hBFDFFF000000FFFF; - zrf = 64'hC34FFFFFBFE00000; - ans = 64'hC3C01F7FFFF05E7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2090669\n"); - end - xrf = 64'hC7E0000007FFFFF6; - y = 64'hFFF0000000000000; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2091283\n"); - end - xrf = 64'h4010000000000001; - y = 64'hCD22000000200000; - zrf = 64'hC3DFFFFFFFF7FFFE; - ans = 64'hCD42000000200001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2091897\n"); - end - xrf = 64'hC1C0800003FFFFFF; - y = 64'hFFF0000000000001; - zrf = 64'hC1DFFFFFCFFFFFFF; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2092511\n"); - end - xrf = 64'h4010000000000001; - y = 64'hC3A00001FEFFFFFE; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'hC3C00001FEFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2093125\n"); - end - xrf = 64'h321FFFFFDC000000; - y = 64'hC3400000001FEFFF; - zrf = 64'h43EFFFFFDFFEFFFF; - ans = 64'h43EFFFFFDFFEFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2093739\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h0000000000000000; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h001FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2094353\n"); - end - xrf = 64'hC7E7BF896056C7B0; - y = 64'hC1FFFFFFFEFBFFFE; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'h49F7BF895F95D372; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2094967\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h0000000000000001; - zrf = 64'h462FFFFFFFFFFFFF; - ans = 64'h462FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2095581\n"); - end - xrf = 64'h802000000007FF7F; - y = 64'h7FE0000001FFBFFE; - zrf = 64'h43F1FFFBFFFFFFFE; - ans = 64'h43F1FFFBFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2096195\n"); - end - xrf = 64'h427F5A5B8669FAAB; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2096809\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hC3FFFBFFFFFFFFEF; - zrf = 64'hC1D000000000FF7E; - ans = 64'hC42FFC0000007FEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2097423\n"); - end - xrf = 64'h49500000003FFF7E; - y = 64'h0010000000000000; - zrf = 64'hC261FFFF7FFFFFFE; - ans = 64'hC261FFFF7FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2098037\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hC3EA56D05D78BE9F; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2098651\n"); - end - xrf = 64'hC341FFFFBFFFFFFF; - y = 64'h41FC0000007FFFFE; - zrf = 64'hC3F0003FDFFFFFFF; - ans = 64'hC54F80001091FEFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2099265\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h0050FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2099879\n"); - end - xrf = 64'hBD0000000077FFFF; - y = 64'hC110000010000080; - zrf = 64'hC010000000000000; - ans = 64'hC00FFFFFFFC00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2100493\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h3CA0000000000000; - zrf = 64'h988F384F6949CF89; - ans = 64'h3CCFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2101107\n"); - end - xrf = 64'h480B5B7C936D05AE; - y = 64'h41C0000000400FFE; - zrf = 64'hBDA0000008200000; - ans = 64'h49DB5B7C93DA8EF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2101721\n"); - end - xrf = 64'h0BA24ED74A49604E; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h3FD0000000000000; - ans = 64'h3FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2102335\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hBFD001000000001E; - zrf = 64'h381F019FB1D0E921; - ans = 64'hC00001000000001D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2102949\n"); - end - xrf = 64'h434FFFFF77FFFFFE; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h036FFFDFBFFFFFFF; - ans = 64'h400FFFFF77FFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2103563\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h40300000000401FE; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2104177\n"); - end - xrf = 64'h802FFEDFFFFFFFFF; - y = 64'h7FE8008000000000; - zrf = 64'h3E1FFFFFFFF08000; - ans = 64'hC027FFA7FB6FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2104791\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h0000000000000000; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2105405\n"); - end - xrf = 64'hB13FF9FFFFFFFFFF; - y = 64'h7FEB577402A3C99B; - zrf = 64'hC000000000000001; - ans = 64'hF13B52539CE34AE4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2106019\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'hC340000000400002; - ans = 64'hC340000000400000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2106633\n"); - end - xrf = 64'hBEB000000081FFFE; - y = 64'h28400200000FFFFE; - zrf = 64'h0006905A4202FB7C; - ans = 64'hA70002000092103C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2107247\n"); - end - xrf = 64'h49BFFFFFFC07FFFF; - y = 64'h3FE0000000000001; - zrf = 64'h3CA0000000000001; - ans = 64'h49AFFFFFFC080001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2107861\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h4027153765463EB7; - zrf = 64'hBFF0401FFFFFFFFF; - ans = 64'h4056D436E5463EB6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2108475\n"); - end - xrf = 64'hD4B000007FBFFFFF; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h3FBFFFE000000000; - ans = 64'hD4B000007FBFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2109089\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hC4D333B83E26FA35; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2109703\n"); - end - xrf = 64'hDF80000000840000; - y = 64'hC0F65C25999F8D14; - zrf = 64'h3CA0080003FFFFFE; - ans = 64'h60865C259A58054A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2110317\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h3FF0000000000000; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2110931\n"); - end - xrf = 64'h802A7CAC07CCC888; - y = 64'h3B3FFDFFFFFFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2111545\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hB59388B135C6AA9F; - ans = 64'h402FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2112159\n"); - end - xrf = 64'h80200000100000FF; - y = 64'hB500000000001000; - zrf = 64'hBFF9A6A59DDDCA4B; - ans = 64'hBFF9A6A59DDDCA4B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2112773\n"); - end - xrf = 64'hC1EFFFFF800007FF; - y = 64'h4000000000000000; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'hC1FFFFFF800007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2113387\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h7FDEDBBC8C149E63; - zrf = 64'h3DE00000047FFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2114001\n"); - end - xrf = 64'hC80FFFFFC0000007; - y = 64'h4000000000000001; - zrf = 64'h000F69ED724B3CE0; - ans = 64'hC81FFFFFC0000009; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2114615\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h3FA400000003FFFF; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2115229\n"); - end - xrf = 64'h43D1000000000007; - y = 64'h3F80007FF7FFFFFF; - zrf = 64'h43E00000000007F7; - ans = 64'h43E0110087F787F7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2115843\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2116457\n"); - end - xrf = 64'hF0FEFF7FFFFFFFFF; - y = 64'h41C00007FFFF8000; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hF2CEFF8F7FBF0803; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2117071\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h4010000000000001; - zrf = 64'hC050FFFFFFFF0000; - ans = 64'hC041FFFFFFFE0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2117685\n"); - end - xrf = 64'hC010D92032C10045; - y = 64'h62F00000FFFFFFFF; - zrf = 64'hC01FFC0000000002; - ans = 64'hE310D92140530370; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2118299\n"); - end - xrf = 64'h42FFF00000001000; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h432FF00000000FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2118913\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hC34ECB4086F52F1D; - zrf = 64'h4A3FF3FFFFFFFFFE; - ans = 64'h4A3FF3FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2119527\n"); - end - xrf = 64'h41F10001FFFFFFFF; - y = 64'h4340000000000000; - zrf = 64'hE7D000000800FFFF; - ans = 64'hE7D000000800FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2120141\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hC03F62D036C48204; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'hC06E62D036C48203; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2120755\n"); - end - xrf = 64'hC3D00000FFFFFFFB; - y = 64'hC1DFFFFFFE3FFFFF; - zrf = 64'h7FEFFFFFFFEF8000; - ans = 64'h7FEFFFFFFFEF8000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2121369\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'h437BFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2121983\n"); - end - xrf = 64'hC00FF00000007FFF; - y = 64'h3EF0200000000FFF; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE00080BF800003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2122597\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h7FE0000000000000; - zrf = 64'h3FEFEFFFFFBFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2123211\n"); - end - xrf = 64'h8008000004000000; - y = 64'h41DB7E58A68A6ECF; - zrf = 64'h41C46835257E7DE1; - ans = 64'h41C46835257E7DE1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2123825\n"); - end - xrf = 64'h80236BC873359E39; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h0000000000000000; - ans = 64'hC0236BC873359E38; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2124439\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h4C40005FFFFFFFFF; - zrf = 64'hC22FDFFFFC000000; - ans = 64'h4C70005FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2125053\n"); - end - xrf = 64'h43CF80000001FFFF; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hC020000000F7FFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2125667\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hFFD4C24672F919D5; - zrf = 64'h4010000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2126281\n"); - end - xrf = 64'h7FE0000800007FFE; - y = 64'hC350000200000002; - zrf = 64'hBFF0018000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2126895\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h7FF0000000000001; - zrf = 64'hC340000000000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2127509\n"); - end - xrf = 64'h7FE7FFFFFFFFFFDF; - y = 64'h0010002000007FFE; - zrf = 64'hBFD0000000000001; - ans = 64'h400600300000BFDC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2128123\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h3FCFFFFF7FFFFFBE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2128737\n"); - end - xrf = 64'h400FF7DFFFFFFFFF; - y = 64'hBFF03EFFFFFFFFFE; - zrf = 64'h4FAEFFFFFFFFFFF8; - ans = 64'h4FAEFFFFFFFFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2129351\n"); - end - xrf = 64'hBE4001000000007F; - y = 64'h8000000000000000; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2129965\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h3800003FFFFFFDFE; - zrf = 64'hD1C07FFFFDFFFFFF; - ans = 64'hD1C07FFFFDFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2130579\n"); - end - xrf = 64'h43407FF7FFFFFFFF; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hC1EFFFFFFBFF7FFF; - ans = 64'hC1EFFFFFFBFF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2131193\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hC028D8C773920EEF; - zrf = 64'h4000000000000001; - ans = 64'hC05858C773920EEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2131807\n"); - end - xrf = 64'hD6DF800010000000; - y = 64'h369E6917CE8CD5B8; - zrf = 64'hFFE00007FFFFF7FE; - ans = 64'hFFE00007FFFFF7FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2132421\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h8010000000000000; - zrf = 64'hC010000000000001; - ans = 64'hC010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2133035\n"); - end - xrf = 64'h686003FF00000000; - y = 64'h400FFFFFF0000400; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h688003FEF7FE0280; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2133649\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'hC7EFFFFF0000007F; - ans = 64'hC7EFFFFF0000007F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2134263\n"); - end - xrf = 64'hAA0FFFFF80003FFE; - y = 64'hC7EFFF00007FFFFF; - zrf = 64'h3FC00000203FFFFF; - ans = 64'h3FC00000203FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2134877\n"); - end - xrf = 64'hC1CF7FFFFFFFFFFC; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2135491\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h47E0BD1B124969B2; - zrf = 64'h40201FFFFFFFFFBE; - ans = 64'h4810BD1B124969B1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2136105\n"); - end - xrf = 64'h0010000010000080; - y = 64'hBCA0000000000001; - zrf = 64'h3B8D00D9D4D54E0A; - ans = 64'h3B8D00D9D4D54E0A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2136719\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hB7F00000800003FF; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2137333\n"); - end - xrf = 64'h41EFFFFFE01FFFFF; - y = 64'hFFEFF7FFFF800000; - zrf = 64'hFFFD03ECB3953DAA; - ans = 64'hFFFD03ECB3953DAA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2137947\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2138561\n"); - end - xrf = 64'h3FE61D66F271C086; - y = 64'hC3F00000400000FE; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'hC3E61D674AE75DAF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2139175\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hBFD0000000000001; - zrf = 64'h800B3DE08741C4C4; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2139789\n"); - end - xrf = 64'hB81C0000001FFFFF; - y = 64'hB8486203813E1F77; - zrf = 64'h12C0000000400008; - ans = 64'h307555C3112EBD8B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2140403\n"); - end - xrf = 64'hBFC0200000003FFF; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2141017\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h3CAFFFF80FFFFFFF; - zrf = 64'h47220007FFFFFFFF; - ans = 64'h47220007FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2141631\n"); - end - xrf = 64'h61FFFFF003FFFFFF; - y = 64'hBFE0000000000000; - zrf = 64'h43E0000001FFFFF6; - ans = 64'hE1EFFFF003FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2142245\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hC3DFFFFFF0000007; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'hC40FFFFFF0000006; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2142859\n"); - end - xrf = 64'hB7F000001FFFFFFF; - y = 64'hC0EFFFFFFFFFC006; - zrf = 64'h7FEFFC00000FFFFF; - ans = 64'h7FEFFC00000FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2143473\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hC023FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2144087\n"); - end - xrf = 64'h001FFFFFF80007FE; - y = 64'hCA8000040000FFFE; - zrf = 64'h8010000000000000; - ans = 64'h8AB00003FC0102FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2144701\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hBFF0000000000000; - zrf = 64'h41F0007FFFFFFFFC; - ans = 64'h41F0007FFF7FFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2145315\n"); - end - xrf = 64'hC800080000003FFF; - y = 64'h40DFFFFFFFFF7FE0; - zrf = 64'hBFFFFFFFFFFFFF0F; - ans = 64'hC8F007FFFFFFFFCF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2145929\n"); - end - xrf = 64'h49D0008000001FFF; - y = 64'hBFF0000000000001; - zrf = 64'hC340000000000000; - ans = 64'hC9D0008000002000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2146543\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hC7F8000000000002; - zrf = 64'h3FEFFFFFFFFFFFBB; - ans = 64'hC828000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2147157\n"); - end - xrf = 64'hAC48000000000007; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hC020000000040003; - ans = 64'hC020000000040003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2147771\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hC1C7FFFF7FFFFFFF; - zrf = 64'h3FE0000000000000; - ans = 64'hC1F7FFFF7FF7FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2148385\n"); - end - xrf = 64'hBC0007FFFE000000; - y = 64'h8005B72E93CFC238; - zrf = 64'hB1440CD30F8D6060; - ans = 64'hB1440CD30F8D6060; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2148999\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hC000000000000001; - zrf = 64'hBFF0000000000000; - ans = 64'hC031000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2149613\n"); - end - xrf = 64'h3F8FE0007FFFFFFF; - y = 64'h2E710000000001FF; - zrf = 64'h8000000000000001; - ans = 64'h2E10EF00440001FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2150227\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h43F0080000000008; - ans = 64'h43F0080000000008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2150841\n"); - end - xrf = 64'h3FF0040000080000; - y = 64'h4F30F7CEC7A64330; - zrf = 64'h5910E7DF0960199B; - ans = 64'h5910E7DF0960199B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2151455\n"); - end - xrf = 64'h3FBF800003FFFFFE; - y = 64'hC010000000000000; - zrf = 64'hC010000000000001; - ans = 64'hC011F80000400001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2152069\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hC01FFFFEDFFFFFFE; - zrf = 64'h41D0000FDFFFFFFF; - ans = 64'h41D0000FD000008F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2152683\n"); - end - xrf = 64'hC090001FFF000000; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hC010000001FFFFE0; - ans = 64'h40BFFC3FFDFF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2153297\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h414DFFFFFFFDFFFE; - zrf = 64'h3FD0000000000001; - ans = 64'h417E000003FDFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2153911\n"); - end - xrf = 64'hADF0000000000101; - y = 64'h47FFFFBFFFFFFFEE; - zrf = 64'h768FFFEFFFFFFDFF; - ans = 64'h768FFFEFFFFFFDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2154525\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hC340000000000000; - zrf = 64'hBFE0000000000001; - ans = 64'hC36FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2155139\n"); - end - xrf = 64'h40C000000007FFFA; - y = 64'h43CFFFFFFBFFFFDF; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2155753\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hCEDFFFFFD0000000; - ans = 64'hCEDFFFFFD0000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2156367\n"); - end - xrf = 64'hC030001FF0000000; - y = 64'h24600023FFFFFFFF; - zrf = 64'hC1DFFFBFFFFF7FFF; - ans = 64'hC1DFFFBFFFFF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2156981\n"); - end - xrf = 64'hB9E00FFFFFFFF800; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2157595\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hC34FFFFFFFF20000; - zrf = 64'h4034001FFFFFFFFE; - ans = 64'hC37FFFFFFFF1FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2158209\n"); - end - xrf = 64'hC3CFFFFFBFFDFFFF; - y = 64'hFFE0000000000001; - zrf = 64'h4D70400000000FFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2158823\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'h001B5645AEF74677; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2159437\n"); - end - xrf = 64'h434C0975C90677C8; - y = 64'h380FF0000000001F; - zrf = 64'hB7F11D571313021E; - ans = 64'h3B6BFB710E21F4A7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2160051\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2160665\n"); - end - xrf = 64'h3FC1FFFFFFE00000; - y = 64'h3FB2000000000003; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2161279\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hFFF0000000000001; - zrf = 64'hC3D3FFFFFFE00000; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2161893\n"); - end - xrf = 64'hC3F00000011FFFFF; - y = 64'hCC3FFFFFFFFFE00E; - zrf = 64'hA29FFFFFFFFFF7FE; - ans = 64'h50400000011FF006; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2162507\n"); - end - xrf = 64'hC3D4800000000000; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2163121\n"); - end - xrf = 64'h401FFFFFFFFFFFFF; - y = 64'hFFD0D5461AB97F96; - zrf = 64'h41CB0920A36D44D9; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2163735\n"); - end - xrf = 64'h41FFF7FFFFFFFFDE; - y = 64'h0000000000000000; - zrf = 64'hE76A841E3E18C6FF; - ans = 64'hE76A841E3E18C6FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2164349\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h41E020000007FFFF; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h421020000007FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2164963\n"); - end - xrf = 64'hC3FE4FBC9B42F5B4; - y = 64'h40200080000007FE; - zrf = 64'hB80FF7FFFFDFFFFF; - ans = 64'hC42E50AF1927DEF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2165577\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hBCAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2166191\n"); - end - xrf = 64'h480BCB365F69F57F; - y = 64'h40738DF7B187116B; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2166805\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h0010000000000000; - zrf = 64'hC000070A5DABB9D0; - ans = 64'hC000070A5DABB9D0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2167419\n"); - end - xrf = 64'h2CC928717C7B85D4; - y = 64'hBE37BC475F020AD5; - zrf = 64'h41EFFFFFFFFEFDFF; - ans = 64'h41EFFFFFFFFEFDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2168033\n"); - end - xrf = 64'hBFC144B4875A348D; - y = 64'h0010000000000001; - zrf = 64'hBFF0000000000000; - ans = 64'hBFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2168647\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h2840000080000000; - zrf = 64'h4030922251CA0B50; - ans = 64'h4030922251CA0B50; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2169261\n"); - end - xrf = 64'h402FFFFBFF7FFFFF; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hF8CFFE007FFFFFFF; - ans = 64'hF8CFFE007FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2169875\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hC0FBFFFFFFFFFFF0; - zrf = 64'h0010000000000000; - ans = 64'hC12BFFFFFFFFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2170489\n"); - end - xrf = 64'hC500000800800000; - y = 64'h41FFFFFFFFBFFFFC; - zrf = 64'hB80BD40508FA289F; - ans = 64'hC7100008005FFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2171103\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h3CA0000000000001; - zrf = 64'hBCA0000000000000; - ans = 64'h3CCC000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2171717\n"); - end - xrf = 64'h3CA0000080000FFE; - y = 64'h380DFFFF00000000; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2172331\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h000FFFFDFFFFEFFF; - ans = 64'h3CDFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2172945\n"); - end - xrf = 64'hC3F000000003FF00; - y = 64'h405BFFFFFE000000; - zrf = 64'h3FAFFFFFFFFE1FFF; - ans = 64'hC45BFFFFFE06FE40; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2173559\n"); - end - xrf = 64'hBFD911DFB7F9CEDD; - y = 64'h3FD0000000000000; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE3223BF6FF39DD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2174173\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h32EFFFFFF7F7FFFF; - zrf = 64'hC800000000FFFFC0; - ans = 64'hC800000000FFFFC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2174787\n"); - end - xrf = 64'hBF0FFFFF10000000; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hC950000BFFFFFFFF; - ans = 64'hC950000BFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2175401\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hC0E00100000001FE; - zrf = 64'h0000000000000001; - ans = 64'hC1100100000001FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2176015\n"); - end - xrf = 64'hC1FFFDFFFFF80000; - y = 64'h40AFFC000000003E; - zrf = 64'h7FD69A1CC85982DA; - ans = 64'h7FD69A1CC85982DA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2176629\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h3FE0000000000000; - zrf = 64'h8010000000000001; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2177243\n"); - end - xrf = 64'hBC30400000FFFFFE; - y = 64'hC02FFFBFF7FFFFFF; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h401FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2177857\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h41FFFFFB7FFFFFFF; - ans = 64'h41FFFFFB807FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2178471\n"); - end - xrf = 64'hBFE3DC34614FE233; - y = 64'h407F3395996D3BDD; - zrf = 64'h000FFFFFFFFFFFF5; - ans = 64'hC0735D568A4D0539; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2179085\n"); - end - xrf = 64'h43EA1727CA3DE0E5; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'h43EA1727CA3DE0E3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2179699\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hBE2E7FFFFFFFFFFF; - zrf = 64'h3FE0101FFFFFFFFF; - ans = 64'h3FE0101FF0BFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2180313\n"); - end - xrf = 64'h41F352E0B6A41A6F; - y = 64'h3FF0000000000001; - zrf = 64'hC3F1FFFFFFFFF7FE; - ans = 64'hC3F1FFFFFFECA51D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2180927\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hBF139BBEA43347D1; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2181541\n"); - end - xrf = 64'hC03D8D9F3E07CDB5; - y = 64'h434FFFFFFE07FFFF; - zrf = 64'hBF15743D92475450; - ans = 64'hC39D8D9F3C365728; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2182155\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h402FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2182769\n"); - end - xrf = 64'h380733B41F678237; - y = 64'h3FF00000207FFFFF; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2183383\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h4000000000000001; - zrf = 64'hC7F001FFFFFFFF80; - ans = 64'hC7F001FFFFFFFF80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2183997\n"); - end - xrf = 64'h38130C2AD3A6C0EA; - y = 64'h40100001000001FF; - zrf = 64'hB80FFDFFFFFBFFFF; - ans = 64'h382E18D808D3E10A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2184611\n"); - end - xrf = 64'hC6DFFFFFFFFFFF03; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hC6FFFFFFFFFFFF02; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2185225\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hC1F6594B8FFA4BB7; - zrf = 64'h43C2000000000007; - ans = 64'h43C1FFFFFA69AD23; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2185839\n"); - end - xrf = 64'h3FC00000001E0000; - y = 64'h4010000000000000; - zrf = 64'h7B6FFFBFFFFDFFFF; - ans = 64'h7B6FFFBFFFFDFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2186453\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h63DFFEFFFFFFF7FF; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2187067\n"); - end - xrf = 64'h43AFFFFFFFFFFC02; - y = 64'h3E600000002000FF; - zrf = 64'hC1EFFFFFFFE3FFFF; - ans = 64'h421C000000437E00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2187681\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h401FFFFFFFFFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2188295\n"); - end - xrf = 64'hBEEFFFFC000000FF; - y = 64'hC34F7FFFFFFF7FFF; - zrf = 64'h4000000000000000; - ans = 64'h424F7FFC100080FA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2188909\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h4340000000000000; - zrf = 64'hC25D8DAAFC9DDB29; - ans = 64'h436FFFF1392A81AF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2189523\n"); - end - xrf = 64'hC0E000002FFFFFFF; - y = 64'hC00FBFFFBFFFFFFE; - zrf = 64'h0AEFFFFF7EFFFFFF; - ans = 64'h40FFC0001F3FFF3C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2190137\n"); - end - xrf = 64'h4A104315AC3EB886; - y = 64'h4340000000000001; - zrf = 64'hBCA0000000000000; - ans = 64'h4D604315AC3EB887; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2190751\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hC7407FFFFFFFFFFB; - zrf = 64'hC011FFFEFFFFFFFE; - ans = 64'hC7707FFFFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2191365\n"); - end - xrf = 64'hC7FFC00080000000; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hBFB0000004007FFF; - ans = 64'hCB5FC0007FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2191979\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h403FBFFFFFFFFE00; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2192593\n"); - end - xrf = 64'h4032000000003FFF; - y = 64'h3FBFFFFFBFFFFFDF; - zrf = 64'hBD50007FFF000000; - ans = 64'h4001FFFFDC003DEC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2193207\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h7FE0000000000001; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2193821\n"); - end - xrf = 64'h3FEFFDFFFFFF8000; - y = 64'h0005C9224A1E956A; - zrf = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2194435\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h3F8001000000FFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2195049\n"); - end - xrf = 64'hC03FFFFFFEFFFFF0; - y = 64'hB9CFC0000000007F; - zrf = 64'hBFEB1648C4E67458; - ans = 64'hBFEB1648C4E67458; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2195663\n"); - end - xrf = 64'hBEBFFFFFFFF7F7FF; - y = 64'h7FF0000000000000; - zrf = 64'h8010000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2196277\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h820000FFFFFFFFFB; - zrf = 64'h37FFFFFFFFF7FEFE; - ans = 64'h37FFFFFFFFF7FEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2196891\n"); - end - xrf = 64'h7E20BFFFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h3D500000000FBFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2197505\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h28AFBFFFFFFFFFFE; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2198119\n"); - end - xrf = 64'h3064B981E97CBA0F; - y = 64'h5D5FFFFFFFFF01FF; - zrf = 64'h0020004000000001; - ans = 64'h4DD4B981E97C158E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2198733\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h8000000000000000; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2199347\n"); - end - xrf = 64'h801007FFFBFFFFFF; - y = 64'hC030000400000400; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2199961\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h8000000000000001; - zrf = 64'hBBB9E662CC81018C; - ans = 64'hBBB9E662CC81018C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2200575\n"); - end - xrf = 64'hC54002000003FFFF; - y = 64'h3E02EC0486B0BE36; - zrf = 64'h3FD0403FFFFFFFFE; - ans = 64'hC352EE6207464F4E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2201189\n"); - end - xrf = 64'h41FFFFFF80000200; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h821FFFFF801001FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2201803\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hC1E00043FFFFFFFE; - zrf = 64'hB7EFE0000000007E; - ans = 64'hC2100043FFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2202417\n"); - end - xrf = 64'h401007FFEFFFFFFF; - y = 64'h8010000000000001; - zrf = 64'hC7EF672408576C70; - ans = 64'hC7EF672408576C70; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2203031\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h40400007FFEFFFFE; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'h406F000FFFDFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2203645\n"); - end - xrf = 64'hC3848D211BED45F4; - y = 64'h41C40000000FFFFF; - zrf = 64'hC770000000407FFF; - ans = 64'hC77000000046EC19; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2204259\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2204873\n"); - end - xrf = 64'h0E2000207FFFFFFE; - y = 64'hBCCFFFF6FFFFFFFE; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2205487\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hBCA0000000000000; - zrf = 64'hC01EFFFFFFFFFFFE; - ans = 64'hC01EFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2206101\n"); - end - xrf = 64'h37EE0000003FFFFF; - y = 64'hFFEFFFF600000000; - zrf = 64'hBFCFEFFEFFFFFFFF; - ans = 64'hF7EDFFF6A03FFFEB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2206715\n"); - end - xrf = 64'hC050020000000FFF; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2207329\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hC3400003FFFFFFFD; - zrf = 64'h37F0001000000002; - ans = 64'hC3700003FFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2207943\n"); - end - xrf = 64'hBFC0000001BFFFFF; - y = 64'hBFD0000000000000; - zrf = 64'h37F104AA7323DE0F; - ans = 64'h3FA0000001BFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2208557\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h8000001FFF800000; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2209171\n"); - end - xrf = 64'h3EEFEAB58D93A8FE; - y = 64'hB7FFFFFFFFFFE03E; - zrf = 64'h3FF0000000001F7E; - ans = 64'h3FF0000000001F7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2209785\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2210399\n"); - end - xrf = 64'h400BE6A8C346FFA8; - y = 64'h381F7FFFFFFFFFFE; - zrf = 64'h3FD0000000000000; - ans = 64'h3FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2211013\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'hBD60000080008000; - ans = 64'hC0100000000001FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2211627\n"); - end - xrf = 64'h3FFFFFFFF0000000; - y = 64'h3FC4000000000FFE; - zrf = 64'hBFFFFFFFFFFFFFF9; - ans = 64'hBFFB0000027FFBFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2212241\n"); - end - xrf = 64'h41D0000000000807; - y = 64'hBFE0000000000001; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2212855\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h3FDC01FFFFFFFFFE; - zrf = 64'hC3F0000401FFFFFE; - ans = 64'hC3F0000401FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2213469\n"); - end - xrf = 64'hC80F13ECC2137E16; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hFFEFFFF8000003FE; - ans = 64'hFFEFFFF8000003FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2214083\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hC1EFFFFF80040000; - zrf = 64'hC000000000000000; - ans = 64'hC21FFFFF800BFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2214697\n"); - end - xrf = 64'hC000FFFF00000000; - y = 64'hBFC00000003FFF7F; - zrf = 64'h3FAFFFFFFFDFFBFF; - ans = 64'h3FD4FFFF003FFEF3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2215311\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hBFF0000000000001; - zrf = 64'h4010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2215925\n"); - end - xrf = 64'h48A03FFFFFFFBFFF; - y = 64'h4061FF7FFFFFFFFF; - zrf = 64'h3CA0000000000001; - ans = 64'h4912477DFFFFB800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2216539\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h40BFFFBFFFFFF7FF; - ans = 64'h40BFEFBFFFFFF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2217153\n"); - end - xrf = 64'h379ED1F6EA8D1110; - y = 64'hB810000000800100; - zrf = 64'h80203FFFF7FFFFFF; - ans = 64'hAFBED1F6EB83A2B4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2217767\n"); - end - xrf = 64'hC1C05A35ECCACC30; - y = 64'hC000000000000000; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2218381\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hBDD000000800000F; - zrf = 64'h3FCFFFC0001FFFFF; - ans = 64'h3FCFFFBFFF1FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2218995\n"); - end - xrf = 64'h43F000003FFFEFFF; - y = 64'hC000000000000001; - zrf = 64'h001FFFFFE000000E; - ans = 64'hC40000003FFFF000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2219609\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hC1E0008000800000; - zrf = 64'hBFF0000000000001; - ans = 64'hC21000800083FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2220223\n"); - end - xrf = 64'h3FA00000000007C0; - y = 64'h41CFF7FFFFFF7FFE; - zrf = 64'h43CFFFFFFF8003FE; - ans = 64'h43CFFFFFFF8103BE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2220837\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hC010000000000000; - zrf = 64'h4000000000000001; - ans = 64'hC03DFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2221451\n"); - end - xrf = 64'hBFCFFFE0FFFFFFFF; - y = 64'h3FBBCBE88BA8381B; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'hBF9BCBCD9E1EF0CF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2222065\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hC010000000000001; - zrf = 64'h5030000FFFFFFBFF; - ans = 64'h5030000FFFFFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2222679\n"); - end - xrf = 64'h6105A870582F21FC; - y = 64'hC170001FBFFFFFFF; - zrf = 64'h8010000180000000; - ans = 64'hE285A89B526E10F8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2223293\n"); - end - xrf = 64'h41DD898416FC5476; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFE2767BE8F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2223907\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h404FFFFFFFFFFCFF; - zrf = 64'h3FAFFEFFFFFFFFFC; - ans = 64'h4080007FFBFFFE7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2224521\n"); - end - xrf = 64'hC7FFFF80000001FE; - y = 64'hC340000000000000; - zrf = 64'h411FFFFFFFF7FFDE; - ans = 64'h4B4FFF80000001FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2225135\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'h8000C97BEE00D34B; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2225749\n"); - end - xrf = 64'h62FFFFFFF1000000; - y = 64'h3873FFFFFFFFFF80; - zrf = 64'h24AFBFFFFFFFDFFF; - ans = 64'h5B83FFFFF69FFF80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2226363\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'hC37FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2226977\n"); - end - xrf = 64'h304003FFBFFFFFFF; - y = 64'h3FE2FABF1F6AD441; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h3032FF7D8347B277; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2227591\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hFFE0000000000000; - zrf = 64'hA3D00000000FFFFA; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2228205\n"); - end - xrf = 64'hFFFFFFBFF0000000; - y = 64'h4BFFFFFFBFFFFFC0; - zrf = 64'h40F007F7FFFFFFFF; - ans = 64'hFFFFFFBFF0000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2228819\n"); - end - xrf = 64'hBFC000004000000E; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h7FC000004000000D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2229433\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hAE3FFFFFFFEFFFFF; - zrf = 64'h400FFFFFFFE0FFFF; - ans = 64'h400FFFFFFFE0FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2230047\n"); - end - xrf = 64'h47F00FFFFFFBFFFF; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h3FAFFFFFBFFFFFFC; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2230661\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hC02FFF9FFFFFFFFE; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hC0600FCFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2231275\n"); - end - xrf = 64'hC348A49D10BEDDE4; - y = 64'h400276F4846B6206; - zrf = 64'h68D007FFFFFFFFDF; - ans = 64'h68D007FFFFFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2231889\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2232503\n"); - end - xrf = 64'hB8011C56478F348C; - y = 64'h403FFFEFFFFE0000; - zrf = 64'h0000000000000000; - ans = 64'hB8511C4DB962FEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2233117\n"); - end - xrf = 64'h401FFFFFFFFFFFFE; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'hBFEFFFFFF0000000; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2233731\n"); - end - xrf = 64'h3FC11A069589BC39; - y = 64'h3FCF800000004000; - zrf = 64'h40334BF615A75C67; - ans = 64'h40335460E4E4F643; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2234345\n"); - end - xrf = 64'h41900000200001FF; - y = 64'h0000000000000001; - zrf = 64'h4010000000000000; - ans = 64'h4010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2234959\n"); - end - xrf = 64'h4340000000000000; - y = 64'hBFF47A6831A030F5; - zrf = 64'hC34000000007FFFB; - ans = 64'hC3523D3418D41878; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2235573\n"); - end - xrf = 64'h2BB4FBFBC886F231; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h3CA5AB28C6CBDEAA; - ans = 64'h3CA5AB28C6CBDEAA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2236187\n"); - end - xrf = 64'h4340000000000000; - y = 64'hBCF758AF3B14EB32; - zrf = 64'hBFD0000000000000; - ans = 64'hC04778AF3B14EB32; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2236801\n"); - end - xrf = 64'hC1F001FFFFFEFFFF; - y = 64'h480ADA0454848A3E; - zrf = 64'h43EFFFFC0000001F; - ans = 64'hCA0ADD5F950D6D2D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2237415\n"); - end - xrf = 64'h4340000000000000; - y = 64'h0010000000000001; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2238029\n"); - end - xrf = 64'hBFF5EF24C8F3E7E4; - y = 64'hC6B07FFFFE000000; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2238643\n"); - end - xrf = 64'h4340000000000000; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h3FDFFFFFF7FFFF00; - ans = 64'h3FDFFFFFF7FFFF00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2239257\n"); - end - xrf = 64'hC02A9F0B59060CA0; - y = 64'h210FFFFFFFBBFFFE; - zrf = 64'hB810000000FFFF7F; - ans = 64'hB810000000FFFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2239871\n"); - end - xrf = 64'hB7E000000000F000; - y = 64'h3CA0000000000000; - zrf = 64'h4000000000000001; - ans = 64'h4000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2240485\n"); - end - xrf = 64'h4340000000000000; - y = 64'h3D80001FFFEFFFFF; - zrf = 64'hC96FFFFFFFFBF800; - ans = 64'hC96FFFFFFFFBF800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2241099\n"); - end - xrf = 64'hBFC00000000101FF; - y = 64'h3CA0000000000001; - zrf = 64'hBF10000008000003; - ans = 64'hBF10000008000403; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2241713\n"); - end - xrf = 64'h4340000000000000; - y = 64'hBFC531280B222900; - zrf = 64'hBCA0000000000001; - ans = 64'hC31531280B222900; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2242327\n"); - end - xrf = 64'h3CA490ECEFD38623; - y = 64'h414FFFFBFFF7FFFF; - zrf = 64'hD120003FFFDFFFFE; - ans = 64'hD120003FFFDFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2242941\n"); - end - xrf = 64'h4340000000000000; - y = 64'h3FD0000000000000; - zrf = 64'h3FD0000000000001; - ans = 64'h4320000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2243555\n"); - end - xrf = 64'hC1D0003FFFF80000; - y = 64'hC7F0000000FEFFFE; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2244169\n"); - end - xrf = 64'h4340000000000000; - y = 64'h3FD0000000000001; - zrf = 64'hC5F79471ABFF5855; - ans = 64'hC5F79471ABFF57D5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2244783\n"); - end - xrf = 64'hC3C64F7F32A01115; - y = 64'h41D0001FFFBFFFFF; - zrf = 64'h43E00010000007FF; - ans = 64'hC5A64FABD0453757; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2245397\n"); - end - xrf = 64'h3FE8325AA8E5EF61; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h4003064B551CBDEB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2246011\n"); - end - xrf = 64'h4340000000000000; - y = 64'h4B220E85F7748991; - zrf = 64'h5D7BFF8C86E1490E; - ans = 64'h5D7BFF8C86E1490E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2246625\n"); - end - xrf = 64'h00009E4D8E813566; - y = 64'h3FE0000000000000; - zrf = 64'hC8000000001C0000; - ans = 64'hC8000000001C0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2247239\n"); - end - xrf = 64'h4340000000000000; - y = 64'h3FF00007FFFFFF00; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h43400007FFFFFF00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2247853\n"); - end - xrf = 64'h3D19EFC2065BEF14; - y = 64'hBFB0B74B5345ADF2; - zrf = 64'hC3D441E6C3A83622; - ans = 64'hC3D441E6C3A83622; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2248467\n"); - end - xrf = 64'h4340000000000000; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h433FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2249081\n"); - end - xrf = 64'h37FFFFE000004000; - y = 64'h0010003EFFFFFFFF; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2249695\n"); - end - xrf = 64'h4340000000000000; - y = 64'h3FF0000000000000; - zrf = 64'h3FDC11549B9F5AA7; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2250309\n"); - end - xrf = 64'h7FEA9F96DC0C28C0; - y = 64'hC010000000001BFF; - zrf = 64'hC7EFFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2250923\n"); - end - xrf = 64'h41FB29AFFFECD92D; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h420B29AFFFF4D92C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2251537\n"); - end - xrf = 64'h4340000000000000; - y = 64'hEBDFFDFF00000000; - zrf = 64'h413832D2DC13B5B9; - ans = 64'hEF2FFDFF00000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2252151\n"); - end - xrf = 64'hC3D0000080001FFE; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h001EFFFFDFFFFFFF; - ans = 64'hC3E0000080001FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2252765\n"); - end - xrf = 64'h4340000000000000; - y = 64'h32540000000FFFFF; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h35A40000000FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2253379\n"); - end - xrf = 64'hB7EFFFFFFFF7FEFE; - y = 64'hBCCFE0FFFFFFFFFF; - zrf = 64'h403387575FCA1664; - ans = 64'h403387575FCA1664; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2253993\n"); - end - xrf = 64'h4340000000000000; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h435FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2254607\n"); - end - xrf = 64'hC010000010007FFE; - y = 64'hD3C0000000800002; - zrf = 64'hC340000000000000; - ans = 64'h53E0000010808001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2255221\n"); - end - xrf = 64'h4340000000000000; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h40440FFFFFFFFFFE; - ans = 64'h4360000000000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2255835\n"); - end - xrf = 64'hC00C00F1226B2050; - y = 64'h3FFFFFDFFFFFFBFE; - zrf = 64'h37E0000000FDFFFF; - ans = 64'hC01C00D52179FA63; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2256449\n"); - end - xrf = 64'hCD7FFFFFFFFF7FFF; - y = 64'h4010000000000001; - zrf = 64'h3FE0000000000000; - ans = 64'hCD9FFFFFFFFF8001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2257063\n"); - end - xrf = 64'h4340000000000000; - y = 64'h55E00001FEFFFFFE; - zrf = 64'h3CAFBFFFFFDFFFFF; - ans = 64'h59300001FEFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2257677\n"); - end - xrf = 64'hC7FFFFFFFC01FFFE; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hC3EFF0007FFFFFFF; - ans = 64'hC82FFFFFFC01FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2258291\n"); - end - xrf = 64'h4340000000000000; - y = 64'h7FFFFFBFFFFEFFFF; - zrf = 64'h8000000000000000; - ans = 64'h7FFFFFBFFFFEFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2258905\n"); - end - xrf = 64'hBF8FC0000FFFFFFE; - y = 64'hC02FFFFBFFF00000; - zrf = 64'hBFEFFFFFBFF00000; - ans = 64'hBFE81000B9F3F881; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2259519\n"); - end - xrf = 64'h4340000000000000; - y = 64'h4340000000000001; - zrf = 64'h0010000000000000; - ans = 64'h4690000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2260133\n"); - end - xrf = 64'hBFF0003FFF000000; - y = 64'hB13F48933B2117B6; - zrf = 64'hC010000000000001; - ans = 64'hC010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2260747\n"); - end - xrf = 64'h4340000000000000; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h425975F42BB1D3BE; - ans = 64'h469FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2261361\n"); - end - xrf = 64'h43E000000000017E; - y = 64'hBC6FFFFF800003FF; - zrf = 64'hB81000004FFFFFFE; - ans = 64'hC05FFFFF800006FB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2261975\n"); - end - xrf = 64'hC16FFBFFFFFFFFFF; - y = 64'h7FE0000000000000; - zrf = 64'h3FD0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2262589\n"); - end - xrf = 64'h4340000000000000; - y = 64'hBCCFFFFFFE0007FF; - zrf = 64'h41DCB061BF22B973; - ans = 64'h41DCB061BD22B973; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2263203\n"); - end - xrf = 64'hB4400000000FFFFF; - y = 64'h7FE0000000000001; - zrf = 64'hC3476B9F80980CE3; - ans = 64'hF430000000100000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2263817\n"); - end - xrf = 64'h4340000000000000; - y = 64'hBFEF5455E66D6359; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2264431\n"); - end - xrf = 64'hC3D71608E45A0412; - y = 64'hC0180000001FFFFE; - zrf = 64'h6B0000FFFFFFFDFF; - ans = 64'h6B0000FFFFFFFDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2265045\n"); - end - xrf = 64'h4340000000000000; - y = 64'h7FF0000000000000; - zrf = 64'h0000000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2265659\n"); - end - xrf = 64'hB86F21204321D590; - y = 64'hAF3FFFFFFBFFE000; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2266273\n"); - end - xrf = 64'h4340000000000000; - y = 64'h7FF0000000000001; - zrf = 64'hBF8FFFBFFFFFFEFE; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2266887\n"); - end - xrf = 64'h6D50100000007FFF; - y = 64'h41FC0000001FFFFF; - zrf = 64'hC1FF398F11A754F1; - ans = 64'h6F5C1C000020FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2267501\n"); - end - xrf = 64'hFFEA6D705F94B444; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2268115\n"); - end - xrf = 64'h4340000000000000; - y = 64'h41D0003FFFFF0000; - zrf = 64'h3AA3FFFFFFEFFFFF; - ans = 64'h4520003FFFFF0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2268729\n"); - end - xrf = 64'h43FCE6E55903E977; - y = 64'h8000000000000000; - zrf = 64'hBC4FFDFFFFFFF7FF; - ans = 64'hBC4FFDFFFFFFF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2269343\n"); - end - xrf = 64'h4340000000000000; - y = 64'h37EB5BDAF53EB4EB; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2269957\n"); - end - xrf = 64'h3F7FFFFFFFFEF000; - y = 64'h3FDFFFFFF8000100; - zrf = 64'hBED000FFFFFFFBFF; - ans = 64'h3F6FF7FF77FEF102; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2270571\n"); - end - xrf = 64'h4340000000000000; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2271185\n"); - end - xrf = 64'h77CFFFE00000000F; - y = 64'h3F1FFFF80FFFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'h76FFFFD81007F00E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2271799\n"); - end - xrf = 64'h4340000000000000; - y = 64'h8010000000000000; - zrf = 64'hC3707FFFFFFFFDFF; - ans = 64'hC3707FFFFFFFFDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2272413\n"); - end - xrf = 64'h002FFFDFFFFFFFDE; - y = 64'h3E8FF00000000100; - zrf = 64'h40811626F5BEB56D; - ans = 64'h40811626F5BEB56D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2273027\n"); - end - xrf = 64'hC7EC000000000010; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h081C00000000000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2273641\n"); - end - xrf = 64'h4340000000000000; - y = 64'h4010000000000201; - zrf = 64'h801000000200FFFE; - ans = 64'h4360000000000201; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2274255\n"); - end - xrf = 64'h41B0000000000DFF; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h40202FFFAD16AF0E; - ans = 64'h40202FFFAD16AF0E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2274869\n"); - end - xrf = 64'h4340000000000000; - y = 64'hC36D72FC4F782B37; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'hC6BD72FC4F782B37; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2275483\n"); - end - xrf = 64'hDB8FFFFFFE00007E; - y = 64'h9FC000003FDFFFFF; - zrf = 64'h4034F071C6234836; - ans = 64'h4034F071C6234836; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2276097\n"); - end - xrf = 64'h4340000000000000; - y = 64'hBCA0000000000001; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2276711\n"); - end - xrf = 64'h47F00023FFFFFFFF; - y = 64'h359F000020000000; - zrf = 64'hBFF0000000000000; - ans = 64'hBFEFFFFFFFFF07FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2277325\n"); - end - xrf = 64'h4340000000000000; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h64BFFFFFFDFF7FFE; - ans = 64'h64BFFFFFFDFF7FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2277939\n"); - end - xrf = 64'h43DFFFFFFF007FFE; - y = 64'h400FFBFFFFFFBFFF; - zrf = 64'h3FFF8000FFFFFFFF; - ans = 64'h43FFFBFFFF005FED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2278553\n"); - end - xrf = 64'hBF30000000200400; - y = 64'hBFD0000000000001; - zrf = 64'h0010000000000000; - ans = 64'h3F10000000200401; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2279167\n"); - end - xrf = 64'h4340000000000000; - y = 64'h3FFB2B4407EDF5B5; - zrf = 64'hBFD000000001FEFE; - ans = 64'h434B2B4407EDF5B5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2279781\n"); - end - xrf = 64'hC641F08986F4CAEF; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h4037FDFFFFFFFFFE; - ans = 64'h4631F08986F4CAEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2280395\n"); - end - xrf = 64'h4340000000000000; - y = 64'hBFF6A9ACDE055875; - zrf = 64'h4340000000000000; - ans = 64'hC32AA6B3781561D4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2281009\n"); - end - xrf = 64'hC077209428630E48; - y = 64'h3F9BFFFFFFFFFEFF; - zrf = 64'h7DEFFFFFFEFFF800; - ans = 64'h7DEFFFFFFEFFF800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2281623\n"); - end - xrf = 64'h4340000000000000; - y = 64'hBFE0000000000000; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2282237\n"); - end - xrf = 64'hB7EC000000007FFE; - y = 64'h802DFFF7FFFFFFFF; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2282851\n"); - end - xrf = 64'h4340000000000000; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hBFD1311DCA7752FE; - ans = 64'hC33FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2283465\n"); - end - xrf = 64'h7FFC036815DA618A; - y = 64'h3FA2B0315180BE7A; - zrf = 64'h001A394446183D85; - ans = 64'h7FFC036815DA618A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2284079\n"); - end - xrf = 64'h47FFFFFFFFFFFFFF; - y = 64'hBFF0000000000000; - zrf = 64'h0000000000000001; - ans = 64'hC7FFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2284693\n"); - end - xrf = 64'h4340000000000000; - y = 64'hB25FFFDFFFBFFFFF; - zrf = 64'hA20F7F3E8492CDF4; - ans = 64'hB5AFFFDFFFBFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2285307\n"); - end - xrf = 64'hC00D57DC0A031EEA; - y = 64'hBFF0000000000001; - zrf = 64'h4440000040000200; - ans = 64'h4440000040000200; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2285921\n"); - end - xrf = 64'h4340000000000000; - y = 64'hC7F0000BFFFFFFFF; - zrf = 64'h4010000000000001; - ans = 64'hCB40000BFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2286535\n"); - end - xrf = 64'hCD6FFBBFFFFFFFFF; - y = 64'h434FFFFFFF7FFBFF; - zrf = 64'h0020949B37C68B32; - ans = 64'hD0CFFBBFFF800CFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2287149\n"); - end - xrf = 64'h4340000000000000; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hC340000000000001; - ans = 64'hC358000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2287763\n"); - end - xrf = 64'hBFF07FFFFFFEFFFF; - y = 64'hC34FFFFFFFFFEF7F; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'h43507FFFFFFEF77C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2288377\n"); - end - xrf = 64'h4340000000000000; - y = 64'hC000000000000001; - zrf = 64'hC92C1CF2ED58314F; - ans = 64'hC92C1CF2ED58314F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2288991\n"); - end - xrf = 64'h41CCAE6C2A82DBEE; - y = 64'h3CA00001F7FFFFFF; - zrf = 64'h40A8D91B4EE4EC1F; - ans = 64'h40A8D91B4EE881ED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2289605\n"); - end - xrf = 64'h434FF000000003FE; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2290219\n"); - end - xrf = 64'h4340000000000000; - y = 64'hC002CB498F049251; - zrf = 64'h70DFFFFF00003FFE; - ans = 64'h70DFFFFF00003FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2290833\n"); - end - xrf = 64'hC03FFFFFFFC00001; - y = 64'hC010000000000000; - zrf = 64'h7FFFC00000000100; - ans = 64'h7FFFC00000000100; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2291447\n"); - end - xrf = 64'h4340000000000000; - y = 64'hC3EEA4A69C2CA85E; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'hC73EA4A69C2CA85E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2292061\n"); - end - xrf = 64'hC3FFFFFFFB7FFFFF; - y = 64'hCEFDFFFFBFFFFFFF; - zrf = 64'h3CCFFFFFFFC0007F; - ans = 64'h530DFFFFBBC80007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2292675\n"); - end - xrf = 64'h4340000000000000; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC370000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2293289\n"); - end - xrf = 64'hC090010000007FFE; - y = 64'h8007AEAE57E64007; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hBCAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2293903\n"); - end - xrf = 64'h4340000000000000; - y = 64'hC340000000000000; - zrf = 64'hD690000003FFFFF7; - ans = 64'hD690000003FFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2294517\n"); - end - xrf = 64'hB80FFFEFFFFFFFEF; - y = 64'hC3DFFFFFF7FFFFFE; - zrf = 64'h47E887DAC10630D3; - ans = 64'h47E887DAC10630D3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2295131\n"); - end - xrf = 64'hDFAFEFFBFFFFFFFE; - y = 64'hC340000000000001; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2295745\n"); - end - xrf = 64'h4340000000000000; - y = 64'h388FFFFF8000001F; - zrf = 64'hC008001FFFFFFFFE; - ans = 64'hC008001FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2296359\n"); - end - xrf = 64'hC01FFFFFFFBFFDFE; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h3F6FFFFFFFF0FFFF; - ans = 64'h437FFFFFFFBFFDFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2296973\n"); - end - xrf = 64'h4340000000000000; - y = 64'hBFDF5FFFFFFFFFFE; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'hC32F5FFFFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2297587\n"); - end - xrf = 64'hC03EFFFFFFFEFFFF; - y = 64'h401FFFFBC0000000; - zrf = 64'hC011FFFFFDFFFFFF; - ans = 64'hC06F8FFBE1EEFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2298201\n"); - end - xrf = 64'h4340000000000000; - y = 64'hFFE0000000000001; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2298815\n"); - end - xrf = 64'hA71F000000000002; - y = 64'h43E0000007F00000; - zrf = 64'hBCA0000000000000; - ans = 64'hBCA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2299429\n"); - end - xrf = 64'h4340000000000000; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'hC1CFF7FFFFFFFDFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2300043\n"); - end - xrf = 64'h43C0001000000200; - y = 64'h7FF00010007FFFFE; - zrf = 64'hC02FFE000001FFFF; - ans = 64'h7FF80010007FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2300657\n"); - end - xrf = 64'h41E0000800000040; - y = 64'hFFF0000000000000; - zrf = 64'hFFE0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2301271\n"); - end - xrf = 64'h4340000000000000; - y = 64'hBFDF7FFFFF7FFFFF; - zrf = 64'h43DFFFFFFE000003; - ans = 64'h43DFFC0FFE001003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2301885\n"); - end - xrf = 64'hBFB42B92E0CE8966; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h401FFFC000000400; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2302499\n"); - end - xrf = 64'h4340000000000000; - y = 64'hC3E000007FFFFFFE; - zrf = 64'h3FF0000000000000; - ans = 64'hC73000007FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2303113\n"); - end - xrf = 64'h43DBFFFFFFFF0000; - y = 64'h37FB3FA406ED06DD; - zrf = 64'hBF4000007FFFC000; - ans = 64'hBF4000007FFFC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2303727\n"); - end - xrf = 64'h4340000000000001; - y = 64'h0000000000000000; - zrf = 64'hC000000000000000; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2304341\n"); - end - xrf = 64'hBF3000000001FFEE; - y = 64'h7FDFFFFFE001FFFF; - zrf = 64'h8010000000000001; - ans = 64'hFF1FFFFFE005FFDB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2304955\n"); - end - xrf = 64'h4340000000000001; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'hC00000000001EFFF; - ans = 64'hC00000000001EFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2305569\n"); - end - xrf = 64'h41E00000F0000000; - y = 64'hC1FFFFFF801FFFFF; - zrf = 64'h3A0C007FFFFFFFFF; - ans = 64'hC3F00000B00FFC40; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2306183\n"); - end - xrf = 64'h434AA2D8FC9A46F1; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2306797\n"); - end - xrf = 64'h4340000000000001; - y = 64'h5290000FFFFFFF80; - zrf = 64'hC0253D605ADC6994; - ans = 64'h55E0000FFFFFFF81; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2307411\n"); - end - xrf = 64'h40300000047FFFFF; - y = 64'h0010000000000001; - zrf = 64'h40028347123FC721; - ans = 64'h40028347123FC721; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2308025\n"); - end - xrf = 64'h4340000000000001; - y = 64'h402FFDFFFFFFFFFA; - zrf = 64'h3FE0000000000001; - ans = 64'h437FFDFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2308639\n"); - end - xrf = 64'hBFFFFFFFFFF7F7FE; - y = 64'h4003FB7F21F644D6; - zrf = 64'hB81FFFFFF7FFFF80; - ans = 64'hC013FB7F21F140F6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2309253\n"); - end - xrf = 64'h4340000000000001; - y = 64'h001FFFFFFFFFFFFE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2309867\n"); - end - xrf = 64'hC3CFFFFF80010000; - y = 64'h282FFFFFFFFFC000; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'hAC0FFFFF8000C000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2310481\n"); - end - xrf = 64'h4340000000000001; - y = 64'h3CA0000000000001; - zrf = 64'h41D15D35F884E088; - ans = 64'h41D15D35F8C4E088; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2311095\n"); - end - xrf = 64'h401FDFFFFFFFFFFC; - y = 64'h43F8C520AF7D5809; - zrf = 64'h001FFFFFFFFFE7FF; - ans = 64'h4428AC5B8ECDDAAE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2311709\n"); - end - xrf = 64'h37E0000001FBFFFF; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2312323\n"); - end - xrf = 64'h4340000000000001; - y = 64'h404A43217BCC7B0C; - zrf = 64'h3E8000080003FFFF; - ans = 64'h439A43217BCC7B0E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2312937\n"); - end - xrf = 64'h60F00000200001FF; - y = 64'h3FD0000000000000; - zrf = 64'hBFDEFFFFFFFFEFFF; - ans = 64'h60D00000200001FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2313551\n"); - end - xrf = 64'h4340000000000001; - y = 64'h7FFFFFFFFFFFFC06; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFC06; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2314165\n"); - end - xrf = 64'hC0225253367BEB29; - y = 64'hBFFFFC00000FFFFE; - zrf = 64'h3F0FFDFFFFC00000; - ans = 64'h4032500CEBDE44CC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2314779\n"); - end - xrf = 64'h4340000000000001; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'h432FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2315393\n"); - end - xrf = 64'h434000000003FFFF; - y = 64'h43479024D7FF09EF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2316007\n"); - end - xrf = 64'h4340000000000001; - y = 64'h3FE0000000000000; - zrf = 64'h33DFFE000FFFFFFF; - ans = 64'h4330000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2316621\n"); - end - xrf = 64'h37E0000000000000; - y = 64'h79D7A559DDB1F430; - zrf = 64'h3E70001000001FFF; - ans = 64'h71C7A559DDB1F430; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2317235\n"); - end - xrf = 64'hC7FF80000FFFFFFF; - y = 64'h3FE0000000000001; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC7EF800010000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2317849\n"); - end - xrf = 64'h4340000000000001; - y = 64'hBCAB7CDC15514299; - zrf = 64'hC3F000001FFFF7FF; - ans = 64'hC3F000001FFFF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2318463\n"); - end - xrf = 64'hB05001FFFFF00000; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'hFFFFFFEFFFFFBFFE; - ans = 64'hFFFFFFEFFFFFBFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2319077\n"); - end - xrf = 64'h4340000000000001; - y = 64'h410D90149AC990FB; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h445D90149AC990FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2319691\n"); - end - xrf = 64'h41CFE003FFFFFFFF; - y = 64'h402DFFFFFFFFFFFE; - zrf = 64'h52076C977151EFF0; - ans = 64'h52076C977151EFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2320305\n"); - end - xrf = 64'h4340000000000001; - y = 64'h3FF0000000000001; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'h4340000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2320919\n"); - end - xrf = 64'hC80FEFFFFFFFDFFE; - y = 64'hC8001FDFFFFFFFFF; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2321533\n"); - end - xrf = 64'h4340000000000001; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h42900000010000FF; - ans = 64'h4350010000001000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2322147\n"); - end - xrf = 64'hC3D000800007FFFE; - y = 64'hBEBFFFFFFFFFF5FF; - zrf = 64'hC01FFFFF7FF00000; - ans = 64'h42A000800007EAFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2322761\n"); - end - xrf = 64'h41EF6DB877E81671; - y = 64'h4000000000000000; - zrf = 64'hC000000000000000; - ans = 64'h41FF6DB877C81671; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2323375\n"); - end - xrf = 64'h4340000000000001; - y = 64'h7FD0080007FFFFFE; - zrf = 64'hC4B001FFFFFFFE00; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2323989\n"); - end - xrf = 64'h407000400003FFFF; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hFFF0000100003FFF; - ans = 64'hFFF8000100003FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2324603\n"); - end - xrf = 64'h4340000000000001; - y = 64'hFFF003FFFFFFFF7E; - zrf = 64'h3CA0000000000000; - ans = 64'hFFF803FFFFFFFF7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2325217\n"); - end - xrf = 64'hBFE000000000013F; - y = 64'h47AFFE001FFFFFFF; - zrf = 64'h4005F18C2B986B5B; - ans = 64'hC79FFE002000027D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2325831\n"); - end - xrf = 64'h4340000000000001; - y = 64'h4010000000000000; - zrf = 64'hBFD0000000000000; - ans = 64'h4360000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2326445\n"); - end - xrf = 64'hC34FEFFFFFFFFFEE; - y = 64'hC02001FFFFFFFEFE; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2327059\n"); - end - xrf = 64'h4340000000000001; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h3F9040FFFFFFFFFF; - ans = 64'h4370000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2327673\n"); - end - xrf = 64'h37EFFFFDFFEFFFFE; - y = 64'hBFB00000027FFFFE; - zrf = 64'hC34002000000003F; - ans = 64'hC34002000000003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2328287\n"); - end - xrf = 64'h403873F06862F88A; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hBFF0000000000001; - ans = 64'h406853F06862F888; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2328901\n"); - end - xrf = 64'h4340000000000001; - y = 64'hC3DFFFFFFFFFF700; - zrf = 64'h47F297807F5E74B8; - ans = 64'h47F296807F5E74B8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2329515\n"); - end - xrf = 64'hC3FFFFFE00FFFFFF; - y = 64'h4340000000000001; - zrf = 64'h41C6C1CE73976263; - ans = 64'hC74FFFFE01000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2330129\n"); - end - xrf = 64'h4340000000000001; - y = 64'h400DAAF23F993605; - zrf = 64'h0010000000000001; - ans = 64'h435DAAF23F993607; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2330743\n"); - end - xrf = 64'hAFFFFFFFFFF7FF00; - y = 64'h002FFFFF80000200; - zrf = 64'h3F0E34BFD440A8BC; - ans = 64'h3F0E34BFD440A8BC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2331357\n"); - end - xrf = 64'h4340000000000001; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hBCA0000000000001; - ans = 64'h46A0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2331971\n"); - end - xrf = 64'hCAEFFFFFFFFF0FFF; - y = 64'h3F0FFFFFFFCFFFFE; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'hCA0FFFFFFFCF0FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2332585\n"); - end - xrf = 64'h4340000000000001; - y = 64'h7FE0000000000001; - zrf = 64'hA5B07DFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2333199\n"); - end - xrf = 64'h41F0000100003FFF; - y = 64'h3CAFFFFFFFE001FE; - zrf = 64'hC02FFFF8000000FF; - ans = 64'hC02FFFF7DFFFFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2333813\n"); - end - xrf = 64'h7FF0011FFFFFFFFF; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'h7FF8011FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2334427\n"); - end - xrf = 64'h4340000000000001; - y = 64'hC010010000000000; - zrf = 64'h4033FFFFFFFFFFFE; - ans = 64'hC36000FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2335041\n"); - end - xrf = 64'hB2D5935872999FF4; - y = 64'h7FF0000000000000; - zrf = 64'h401000000081FFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2335655\n"); - end - xrf = 64'h4340000000000001; - y = 64'hC06066C8FFE71609; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hC3B066C8FFE7160A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2336269\n"); - end - xrf = 64'h3FD0004000000000; - y = 64'h38A0000000030000; - zrf = 64'hADF07FFFFC000000; - ans = 64'h388000400003000C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2336883\n"); - end - xrf = 64'h4340000000000001; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2337497\n"); - end - xrf = 64'h14C000004007FFFF; - y = 64'h37FFFFFFFF87FFFF; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h401FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2338111\n"); - end - xrf = 64'h4340000000000001; - y = 64'h8000000000000000; - zrf = 64'h43D72945D1D10C0A; - ans = 64'h43D72945D1D10C0A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2338725\n"); - end - xrf = 64'h6CEFFFFDFFFFFBFF; - y = 64'hCF45787D5C8AEF60; - zrf = 64'h39C0003FFFDFFFFF; - ans = 64'hFC45787C050316E8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2339339\n"); - end - xrf = 64'hB925E77B943E3684; - y = 64'h8000000000000001; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2339953\n"); - end - xrf = 64'h4340000000000001; - y = 64'hBC2003FFFFFFFFFE; - zrf = 64'h381FFFFFFFD00000; - ans = 64'hBF7003FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2340567\n"); - end - xrf = 64'h3FFFFBFEFFFFFFFF; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h4034A12AB8ACFA1E; - ans = 64'h4034A12AB8ACFA1E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2341181\n"); - end - xrf = 64'h4340000000000001; - y = 64'h3FE07FFFFFFFFFF0; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2341795\n"); - end - xrf = 64'h434890F6EC8A3B10; - y = 64'h401FFFFFFFF0000F; - zrf = 64'hC7FFEFFFFFFFFFFC; - ans = 64'hC7FFEFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2342409\n"); - end - xrf = 64'h4340000000000001; - y = 64'h8010000000000001; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h8360000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2343023\n"); - end - xrf = 64'hC0F0000000200003; - y = 64'hC3CFFC0000007FFF; - zrf = 64'h4010000000000000; - ans = 64'h44CFFC0000407805; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2343637\n"); - end - xrf = 64'h4340000000000001; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h334F7FFBFFFFFFFE; - ans = 64'h334F7FFBFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2344251\n"); - end - xrf = 64'hC3C00000003FFFFF; - y = 64'h38C0000000FFFBFF; - zrf = 64'hB80624BD323C64F9; - ans = 64'hBC900000013FFBFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2344865\n"); - end - xrf = 64'hC1F00000000000FB; - y = 64'hBCA0000000000000; - zrf = 64'hBFD0000000000000; - ans = 64'hBFCFFFFC00000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2345479\n"); - end - xrf = 64'h4340000000000001; - y = 64'h3FFBFFFFFFFFFFEF; - zrf = 64'hC01FF800000003FF; - ans = 64'h434BFFFFFFFFFFED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2346093\n"); - end - xrf = 64'h41EAD27A45E8198B; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h9660000001FFFFEE; - ans = 64'hBEAAD27A45E8198A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2346707\n"); - end - xrf = 64'h4340000000000001; - y = 64'h17CFDFFFFFFFFFFC; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2347321\n"); - end - xrf = 64'h800FFFFFF7FDFFFF; - y = 64'h3E2FFF7BFFFFFFFF; - zrf = 64'h4AC1FFEFFFFFFFFF; - ans = 64'h4AC1FFEFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2347935\n"); - end - xrf = 64'h4340000000000001; - y = 64'hBFD0000000000000; - zrf = 64'h8000000000000000; - ans = 64'hC320000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2348549\n"); - end - xrf = 64'hCF5FFFFFFFEFE000; - y = 64'hC023FFFFFFE00000; - zrf = 64'h4000000000000001; - ans = 64'h4F93FFFFFFD5EC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2349163\n"); - end - xrf = 64'h4340000000000001; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hC7FFFFE1FFFFFFFF; - ans = 64'hC7FFFFE1FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2349777\n"); - end - xrf = 64'hC51FFC00000FFFFF; - y = 64'hC1D7FFFFFFFFF7FE; - zrf = 64'hB8C0500000000000; - ans = 64'h4707FD00000BF7FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2350391\n"); - end - xrf = 64'h3FED5F03FF053628; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'hBCA0000000000001; - ans = 64'hBFDD5F03FF053628; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2351005\n"); - end - xrf = 64'h4340000000000001; - y = 64'h37ECFFFFFFFFFFFE; - zrf = 64'h3CFFDFFFFFFFFFFE; - ans = 64'h3CFFE00001CFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2351619\n"); - end - xrf = 64'h445FFFFFF8000007; - y = 64'hBFE0000000000001; - zrf = 64'h41F528D1252D9058; - ans = 64'hC44FFFFFF7FF56C2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2352233\n"); - end - xrf = 64'h4340000000000001; - y = 64'h41FE7CFA871C6E01; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2352847\n"); - end - xrf = 64'hFFD00FFFFFFFFFFC; - y = 64'h401FFEF000000000; - zrf = 64'hC69FFFFFFFF001FF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2353461\n"); - end - xrf = 64'h4340000000000001; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2354075\n"); - end - xrf = 64'h3FF0400001FFFFFF; - y = 64'hBFB00000010000FF; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h3FFEFBFFFFCFBFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2354689\n"); - end - xrf = 64'h4340000000000001; - y = 64'hBFF0000000000001; - zrf = 64'hBFE0000010FFFFFF; - ans = 64'hC340000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2355303\n"); - end - xrf = 64'hC3409FFFFFFFFFFE; - y = 64'hFFFFFFF7FFFFFFBE; - zrf = 64'h41D71184951FDAC6; - ans = 64'hFFFFFFF7FFFFFFBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2355917\n"); - end - xrf = 64'hBFE000003BFFFFFE; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h3FF000003BFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2356531\n"); - end - xrf = 64'h4340000000000001; - y = 64'h30D07FFF80000000; - zrf = 64'hC34FFFF00001FFFE; - ans = 64'hC34FFFF00001FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2357145\n"); - end - xrf = 64'h3FC000002000000F; - y = 64'hC000000000000000; - zrf = 64'h43D00000001F7FFF; - ans = 64'h43D00000001F7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2357759\n"); - end - xrf = 64'h4340000000000001; - y = 64'h3FDFFF0000001000; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC348003FFFFFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2358373\n"); - end - xrf = 64'h48001FFFFFFFFFFC; - y = 64'h3F32E0A31D93728A; - zrf = 64'hBFFFFFFFFF003FFF; - ans = 64'h4743066463CE996A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2358987\n"); - end - xrf = 64'h4340000000000001; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2359601\n"); - end - xrf = 64'hCDFFFFFFF00000FE; - y = 64'h5ECF800007FFFFFE; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'hECDF7FFFF84000F4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2360215\n"); - end - xrf = 64'h4340000000000001; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h7FE00003FFFFC000; - ans = 64'h7FE00003FFFFC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2360829\n"); - end - xrf = 64'h34C20BA1CFD35142; - y = 64'h40102003FFFFFFFF; - zrf = 64'h47E03FFFFFFFFFFF; - ans = 64'h47E03FFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2361443\n"); - end - xrf = 64'h3FBF19DC6F82A36E; - y = 64'hC010000000000001; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hBFDF19DC6F82A370; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2362057\n"); - end - xrf = 64'h4340000000000001; - y = 64'h8D6A9D993D1D2C6E; - zrf = 64'hB9A3089D3E427A9F; - ans = 64'hB9A3089D3E427A9F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2362671\n"); - end - xrf = 64'hC3D0000100000001; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h44CFFF8040000000; - ans = 64'h44D0004020080000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2363285\n"); - end - xrf = 64'h4340000000000001; - y = 64'h7FD8140C75BE2D61; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2363899\n"); - end - xrf = 64'hFFFFE00000002000; - y = 64'h41F813AD63F0CC13; - zrf = 64'h802FFFFFFFF7FFC0; - ans = 64'hFFFFE00000002000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2364513\n"); - end - xrf = 64'h4340000000000001; - y = 64'hC340000000000001; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'hC690000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2365127\n"); - end - xrf = 64'hBCB58BA32DF145E0; - y = 64'h3FBE0000003FFFFF; - zrf = 64'h3FE0000000000000; - ans = 64'h3FDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2365741\n"); - end - xrf = 64'h4340000000000001; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hBDD3EF62FAA25F5B; - ans = 64'hC6A0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2366355\n"); - end - xrf = 64'hC7EFFFFFFFFEFFDE; - y = 64'hBFC10003FFFFFFFE; - zrf = 64'hFFDFFFFFFFFFF000; - ans = 64'hFFDFFFFFFFFFF000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2366969\n"); - end - xrf = 64'hDF2FFFFF800000FE; - y = 64'hFFE0000000000000; - zrf = 64'h8000000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2367583\n"); - end - xrf = 64'h4340000000000001; - y = 64'hBE8ADC8A28E4158C; - zrf = 64'h3FFFFFFFFFFEEFFF; - ans = 64'hC1DADC8A2864158E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2368197\n"); - end - xrf = 64'hCF4FE0FFFFFFFFFE; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h38CD934899ED1CBD; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2368811\n"); - end - xrf = 64'h4340000000000001; - y = 64'hFFEFFF800001FFFF; - zrf = 64'hC010000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2369425\n"); - end - xrf = 64'h402FFC00000000FF; - y = 64'h3CAFFFFFFEFFFFF6; - zrf = 64'hC3F0000803FFFFFF; - ans = 64'hC3F0000803FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2370039\n"); - end - xrf = 64'h4340000000000001; - y = 64'hFFF0000000000000; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2370653\n"); - end - xrf = 64'hC3DFFFFFFBDFFFFF; - y = 64'hFFF0000040080000; - zrf = 64'h3FD0000000000001; - ans = 64'hFFF8000040080000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2371267\n"); - end - xrf = 64'h4340000000000001; - y = 64'hFFF0000000000001; - zrf = 64'h7D5FFDFF7FFFFFFF; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2371881\n"); - end - xrf = 64'h4000007FFFFFFF7E; - y = 64'h3FDCACB54358D66E; - zrf = 64'hFFD07FFFFFFFFFFA; - ans = 64'hFFD07FFFFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2372495\n"); - end - xrf = 64'hBFE1329CAFA09F26; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h7FF0000000000001; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2373109\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hBF97E2B472C87667; - zrf = 64'hBFDDFC0000000000; - ans = 64'hC2F7E2B472C8766E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2373723\n"); - end - xrf = 64'hC3CB5CC56722BF2E; - y = 64'h0000000000000001; - zrf = 64'h4347A6A653DCE7C6; - ans = 64'h4347A6A653DCE7C6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2374337\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h80200000000001DF; - zrf = 64'hC000000000000001; - ans = 64'hC000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2374951\n"); - end - xrf = 64'hC0B000000E000000; - y = 64'hC7EFF7BFFFFFFFFF; - zrf = 64'hBBA001FFFFFFFEFF; - ans = 64'h48AFF7C01BF8C7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2375565\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h4010000000000001; - ans = 64'h4010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2376179\n"); - end - xrf = 64'h47FBAFD5DD1373A4; - y = 64'h41C00000000003FB; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h49CBAFD5DD137A87; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2376793\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h0010000000000000; - zrf = 64'hB7EA274BBE534719; - ans = 64'hB7EA274BBE534719; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2377407\n"); - end - xrf = 64'h3F7FFFFFFFF80FFF; - y = 64'hB7E0000000400020; - zrf = 64'h43E0000200000000; - ans = 64'h43E0000200000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2378021\n"); - end - xrf = 64'hC3EBFFFFFFFFFFFB; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2378635\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h402FFF7FFFF00000; - zrf = 64'hFFDDFFFFFF7FFFFE; - ans = 64'hFFDDFFFFFF7FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2379249\n"); - end - xrf = 64'hC7ED8AB087F5C05B; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h3FB7FFFFFFFF7FFF; - ans = 64'h3FB7FFFFFFFF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2379863\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h3F00080002000000; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'h4260080001FFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2380477\n"); - end - xrf = 64'h402020000001FFFF; - y = 64'hBFDFFFFFFFBBFFFF; - zrf = 64'hC03F214815D6A0C8; - ans = 64'hC04194A40AE747E4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2381091\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h401FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2381705\n"); - end - xrf = 64'h47FD9D82C52C1E71; - y = 64'h801FFFFFFFC0001F; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h882D9D82C4F0E388; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2382319\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h802DCFE0F56C6C8F; - ans = 64'h400FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2382933\n"); - end - xrf = 64'hC3C000000000203F; - y = 64'h41CFFFFFEFFFFDFF; - zrf = 64'h179FFFFFFFFFBF7F; - ans = 64'hC59FFFFFF0003E7D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2383547\n"); - end - xrf = 64'h401FFFFFFFFE1FFF; - y = 64'h3FD0000000000001; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2384161\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h3FBFFFFFFFFFFFC3; - zrf = 64'hC04DFFFE00000000; - ans = 64'h431FFFFFFFFFFED2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2384775\n"); - end - xrf = 64'h47DFFFFF7DFFFFFF; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h47FFF00001FFFFFE; - ans = 64'h4801F7FFF8DFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2385389\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h44FFFFFFEFFFFFFE; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'h485FFFFFEFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2386003\n"); - end - xrf = 64'hBF9FFFFFBFFFFFBF; - y = 64'h406FFFFFFFC01FFF; - zrf = 64'h3FFFFDFFFFFFFF00; - ans = 64'hC018007FBFC01FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2386617\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h3FE0000000000001; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2387231\n"); - end - xrf = 64'h4370003FFFFFFEFE; - y = 64'h41C4C250A2F4F548; - zrf = 64'h0010000000000000; - ans = 64'h4544C2A3AC377FCD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2387845\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h411FDFDFFFFFFFFF; - ans = 64'h435000000001FDFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2388459\n"); - end - xrf = 64'hC065E9EF4F9D3E21; - y = 64'hFFDE0F6202282F1D; - zrf = 64'hC0906DD67E9476DC; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2389073\n"); - end - xrf = 64'hBFED82E3C6C037DB; - y = 64'h3FF0000000000000; - zrf = 64'h4340000000000000; + z = 64'h4340000000000000; ans = 64'h433FFFFFFFFFFFFF; rn = 1; rz = 0; @@ -182935,19 +44988,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -182963,12 +45016,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2389687\n"); + $fwrite(fp,"1927397\n"); end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hC020004000003FFF; - zrf = 64'hBA8FFF80000003FF; - ans = 64'hC380004000003FFE; + x = 64'h44F00000020001FF; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hBF2DFFFFFFFDFFFE; + ans = 64'hC4E00000020001FE; rn = 1; rz = 0; rm = 0; @@ -182982,19 +45035,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -183010,12 +45063,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2390301\n"); + $fwrite(fp,"1929411\n"); end - xrf = 64'h3FFC000000000800; - y = 64'h3FF0000000000001; - zrf = 64'h43EFFC0000003FFF; - ans = 64'h43EFFC0000003FFF; + x = 64'hC3440000001FFFFF; + y = 64'h4026DAC6A72B13B9; + z = 64'hC0000000003FC000; + ans = 64'hC37C917851238E33; rn = 1; rz = 0; rm = 0; @@ -183029,19 +45082,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -183057,12 +45110,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2390915\n"); + $fwrite(fp,"1931425\n"); end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h40200000200000FE; - zrf = 64'hBFE0000000000000; - ans = 64'h43800000200000FD; + x = 64'h400FFFFFFFFFFFFE; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -183076,19 +45129,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -183104,12 +45157,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2391529\n"); + $fwrite(fp,"1933439\n"); end - xrf = 64'h401FFFFFFDEFFFFF; - y = 64'hBEBFFFFFFDFDFFFF; - zrf = 64'hBFBFFFFFFFC0007F; - ans = 64'hBFC0007FFFDFEFF7; + x = 64'hC030000000107FFE; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hC3C0800000002000; + ans = 64'hC3C0800000002000; rn = 1; rz = 0; rm = 0; @@ -183123,19 +45176,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -183151,12 +45204,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2392143\n"); + $fwrite(fp,"1935453\n"); end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h4000000000000000; - zrf = 64'h3FF0000000000000; - ans = 64'h435FFFFFFFFFFFFF; + x = 64'hF11FFC00000001FE; + y = 64'h3802000000008000; + z = 64'hBF201FFFFFFFFF7E; + ans = 64'hE931FDC00000810F; rn = 1; rz = 0; rm = 0; @@ -183170,19 +45223,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -183198,12 +45251,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2392757\n"); + $fwrite(fp,"1937467\n"); end - xrf = 64'hC3DFFFFFFD7FFFFE; - y = 64'hC1C7D668CDFFE997; - zrf = 64'h0000000000000001; - ans = 64'h45B7D668CC232965; + x = 64'h400FFFFFFFFFFFFE; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hC02FFFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -183217,19 +45270,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -183245,12 +45298,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2393371\n"); + $fwrite(fp,"1939481\n"); end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h4000000000000001; - zrf = 64'h9010FFFFFFFEFFFF; - ans = 64'h4360000000000000; + x = 64'h41C00000000FFFEF; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h40700007FFFBFFFE; + ans = 64'hC1EFFFFFE01FEFDD; rn = 1; rz = 0; rm = 0; @@ -183264,19 +45317,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -183292,12 +45345,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2393985\n"); + $fwrite(fp,"1941495\n"); end - xrf = 64'h000FFC1FFFFFFFFF; - y = 64'h3FBFFFFFF0001FFF; - zrf = 64'h01A54E0A36E764E7; - ans = 64'h01A54E0A37E726E7; + x = 64'h43400FFFFFFFC000; + y = 64'hC02FFE0000004000; + z = 64'hB0E5C63EF0C86421; + ans = 64'hC3800EFEFFFFE024; rn = 1; rz = 0; rm = 0; @@ -183311,19 +45364,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -183339,12 +45392,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2394599\n"); + $fwrite(fp,"1943509\n"); end - xrf = 64'hB80FFFFFFFFFFFFE; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h4010000000000001; - ans = 64'h4010000000000001; + x = 64'h400FFFFFFFFFFFFE; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'hC36FFFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -183358,19 +45411,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -183386,12 +45439,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2395213\n"); + $fwrite(fp,"1945523\n"); end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hBFF3FFF7FFFFFFFF; - zrf = 64'hC7FD05FDFF73E632; - ans = 64'hC7FD05FDFF73E632; + x = 64'h3FDFFFFFFFFF8006; + y = 64'hFFE0000000000001; + z = 64'h400FFDFFFFFBFFFE; + ans = 64'hFFCFFFFFFFFF8008; rn = 1; rz = 0; rm = 0; @@ -183405,19 +45458,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -183433,12 +45486,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2395827\n"); + $fwrite(fp,"1947537\n"); end - xrf = 64'h800FFFFFFFFFBFDE; - y = 64'h4010000000000000; - zrf = 64'h55B0AE982E8F89CC; - ans = 64'h55B0AE982E8F89CC; + x = 64'hBFE8F26BC072A863; + y = 64'hB81FFFFFFFF00000; + z = 64'h381000020FFFFFFF; + ans = 64'h38247936E8331796; rn = 1; rz = 0; rm = 0; @@ -183452,19 +45505,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -183480,152 +45533,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2396441\n"); + $fwrite(fp,"1949551\n"); end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h3FAF000100000000; - zrf = 64'hBFD0000000000001; - ans = 64'h430F0000FFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2397055\n"); - end - xrf = 64'hBFD001FFFFFFDFFF; - y = 64'hBE4FFFFFFE03FFFE; - zrf = 64'hFFE2BDEF6A61D7BE; - ans = 64'hFFE2BDEF6A61D7BE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2397669\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h3FE0000000000001; - ans = 64'h437FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2398283\n"); - end - xrf = 64'hFFFEEFB34C4329A7; - y = 64'h44AFFFFFFFFFFFFE; - zrf = 64'hFFFFFFFFFFFFFFFF; + x = 64'h400FFFFFFFFFFFFE; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hC340000000000000; ans = 64'hFFFFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -183640,19 +45552,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -183668,12 +45580,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2398897\n"); + $fwrite(fp,"1951565\n"); end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h4340000000000000; - zrf = 64'hBEFF00000000007E; - ans = 64'h469FFFFFFFFFFFFF; + x = 64'h4110000FFFFFFFFF; + y = 64'h0000000000000001; + z = 64'hB250003FFEFFFFFE; + ans = 64'hB250003FFEFFFFFE; rn = 1; rz = 0; rm = 0; @@ -183687,19 +45599,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -183715,12 +45627,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2399511\n"); + $fwrite(fp,"1953579\n"); end - xrf = 64'h002B563D959D14CC; - y = 64'h40F3396D3630BF96; - zrf = 64'h43DFFFFFFFFDFE00; - ans = 64'h43DFFFFFFFFDFE00; + x = 64'h43CA1D89C3DA0FFB; + y = 64'h800000000FF80000; + z = 64'hBFD000000047FFFE; + ans = 64'hBFD000000047FFFE; rn = 1; rz = 0; rm = 0; @@ -183734,19 +45646,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -183762,12 +45674,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2400125\n"); + $fwrite(fp,"1955593\n"); end - xrf = 64'h800FFFFFFFFBF7FE; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h400FFFFFFFFFFFFF; + x = 64'h4010000000000000; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -183781,19 +45693,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -183809,12 +45721,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2400739\n"); + $fwrite(fp,"1957607\n"); end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hB814A433BE51486C; - zrf = 64'hF26000087FFFFFFF; - ans = 64'hF26000087FFFFFFF; + x = 64'hB8EFFFFDFFFFF7FE; + y = 64'h3CA0000000000001; + z = 64'hC34DA4798969E536; + ans = 64'hC34DA4798969E536; rn = 1; rz = 0; rm = 0; @@ -183828,19 +45740,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -183856,12 +45768,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2401353\n"); + $fwrite(fp,"1959621\n"); end - xrf = 64'h40000000001003FF; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hBFF00040000001FF; - ans = 64'h43600000001003FE; + x = 64'h43DFFEFFFFFFFFFB; + y = 64'hC80FC00800000000; + z = 64'h4340404000000000; + ans = 64'hCBFFBF09FFBFFFFB; rn = 1; rz = 0; rm = 0; @@ -183875,19 +45787,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -183903,12 +45815,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2401967\n"); + $fwrite(fp,"1961635\n"); end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hC8000800007FFFFF; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hCB600800007FFFFE; + x = 64'h4010000000000000; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h4000000000000000; rn = 1; rz = 0; rm = 0; @@ -183922,19 +45834,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -183950,12 +45862,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2402581\n"); + $fwrite(fp,"1963649\n"); end - xrf = 64'hB80393169FC8A232; - y = 64'hC0178CD9F52F1A10; - zrf = 64'h3E508001FFFFFFFF; - ans = 64'h3E508001FFFFFFFF; + x = 64'h3D7FDFFFFC000000; + y = 64'h3FE0000000000000; + z = 64'h41E0200000003FFF; + ans = 64'h41E0200000003FFF; rn = 1; rz = 0; rm = 0; @@ -183969,19 +45881,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -183997,12 +45909,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2403195\n"); + $fwrite(fp,"1965663\n"); end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; + x = 64'h000FFFFFFFFFF07F; + y = 64'h41E7FFFFFDFFFFFE; + z = 64'hC3DFFFFFFFF77FFF; + ans = 64'hC3DFFFFFFFF77FFF; rn = 1; rz = 0; rm = 0; @@ -184016,19 +45928,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -184044,12 +45956,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2403809\n"); + $fwrite(fp,"1967677\n"); end - xrf = 64'hC3FF002000000000; - y = 64'hC012B1E30F60CDD3; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; + x = 64'h4010000000000000; + y = 64'h3FF0000000000001; + z = 64'hBFF0000000000001; + ans = 64'h4008000000000002; rn = 1; rz = 0; rm = 0; @@ -184063,19 +45975,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -184091,481 +46003,293 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2404423\n"); + $fwrite(fp,"1969691\n"); end - xrf = 64'h434FFFFFFFFFFFFF; + x = 64'h3FDFFFBFFFFFFFFA; + y = 64'h4000000000000000; + z = 64'h400080003FFFFFFF; + ans = 64'h40087FF03FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1971705\n"); + end + x = 64'h401EFFFFFFFBFFFF; + y = 64'h400C000000000FFF; + z = 64'h3FEE5F5B0DDD3442; + ans = 64'h403C12FAD86B7920; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1973719\n"); + end + x = 64'h4010000000000000; + y = 64'h4010000000000001; + z = 64'h4340000000000000; + ans = 64'h4340000000000008; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1975733\n"); + end + x = 64'h381F8007FFFFFFFE; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hC3FFFFFEFFFC0000; + ans = 64'hC3FFFFFEFFFC0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1977747\n"); + end + x = 64'h3490000000800800; + y = 64'hC47FF7FFBFFFFFFE; + z = 64'h800FC08000000000; + ans = 64'hB91FF7FFC0FFCFF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1979761\n"); + end + x = 64'h4010000000000000; + y = 64'h7FE0000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1981775\n"); + end + x = 64'hC1D03FFFFFFFFF80; y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hC06D84BF2BB77CB8; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2405037\n"); - end - xrf = 64'hC0200003FFFFBFFE; - y = 64'hC060007FFFFFBFFE; - zrf = 64'h37EFFFBFFFFFFFF6; - ans = 64'h40900084001F7FFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2405651\n"); - end - xrf = 64'hBFCFE0000000000F; - y = 64'h7FF0000000000001; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2406265\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hBFDFD933B5463C94; - zrf = 64'hC1F200000000003F; - ans = 64'hC33FD934D5463C93; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2406879\n"); - end - xrf = 64'h47FFFFFFFF800003; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h43DFFFFE0000FFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2407493\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hBCA0001FF0000000; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'hC000001FEFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2408107\n"); - end - xrf = 64'h3F8FFFFFFDFFFEFE; - y = 64'hFFE004000000001F; - zrf = 64'hFFE003FFFFFFFFFB; - ans = 64'hFFE0440FFFFBFEF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2408721\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h8000000000000001; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h3CAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2409335\n"); - end - xrf = 64'hC1F000000000001F; - y = 64'hC00103FFFFFFFFFF; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2409949\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hCDC00200003FFFFE; - ans = 64'hCDC00200003FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2410563\n"); - end - xrf = 64'hC1CFFFF800001FFF; - y = 64'h7FEFFFFFFFF07FFF; - zrf = 64'h47E02DD4EE6F16D6; + z = 64'hC1E54BD798858720; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -184580,19 +46304,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -184608,12 +46332,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2411177\n"); + $fwrite(fp,"1983789\n"); end - xrf = 64'h3E53A6C3B8E56152; - y = 64'h8010000000000000; - zrf = 64'h3FF0000000000000; - ans = 64'h3FF0000000000000; + x = 64'hEA9F41DC9A5B6689; + y = 64'hFFE00000041FFFFE; + z = 64'hC7AD37E607EEC4B6; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -184627,19 +46351,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -184655,12 +46379,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2411791\n"); + $fwrite(fp,"1985803\n"); end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hC7EEFFFFFFFFFFBE; - zrf = 64'h3FF20000000FFFFF; - ans = 64'hCB4EFFFFFFFFFFBD; + x = 64'h4010000000000000; + y = 64'h8000000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -184674,19 +46398,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -184702,12 +46426,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2412405\n"); + $fwrite(fp,"1987817\n"); end - xrf = 64'h402FFFF80FFFFFFF; - y = 64'h8010000000000001; - zrf = 64'hC1437E9173E00C82; - ans = 64'hC1437E9173E00C82; + x = 64'hC1E788895620064F; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hC00F00FFFFFFFFFE; + ans = 64'hC00F00FFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -184721,19 +46445,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -184749,12 +46473,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2413019\n"); + $fwrite(fp,"1989831\n"); end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hB810008000001FFE; - zrf = 64'h8010000000000000; - ans = 64'hBB70008000001FFD; + x = 64'h3FCFFFFFFFE00000; + y = 64'hAA26A278E9C77CA7; + z = 64'hA3A04316FDB9DFA9; + ans = 64'hAA06A278E9B0DA2E; rn = 1; rz = 0; rm = 0; @@ -184768,19 +46492,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -184796,59 +46520,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2413633\n"); + $fwrite(fp,"1991845\n"); end - xrf = 64'hC001FFE4B8134224; - y = 64'hBFD0000000037FFF; - zrf = 64'h7FE20000FFFFFFFF; - ans = 64'h7FE20000FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2414247\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; + x = 64'h4010000000000000; y = 64'hBCA0000000000000; - zrf = 64'h3CA0000000000000; - ans = 64'hBFFFFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h3FEFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -184862,19 +46539,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -184890,11 +46567,105 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2414861\n"); + $fwrite(fp,"1993859\n"); end - xrf = 64'h3FEFFF7FFFFFFEFF; - y = 64'h8020002000000006; - zrf = 64'hC340000000000001; + x = 64'hC0100010003FFFFE; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hC3D000003F7FFFFF; + ans = 64'hC3D000003F7FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1995873\n"); + end + x = 64'hBFC0040FFFFFFFFF; + y = 64'h34100FFFFFEFFFFE; + z = 64'h3FC00000000000FE; + ans = 64'h3FC00000000000FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"1997887\n"); + end + x = 64'h4010000000000000; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hC340000000000000; ans = 64'hC340000000000001; rn = 1; rz = 0; @@ -184909,19 +46680,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -184937,529 +46708,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2415475\n"); + $fwrite(fp,"1999901\n"); end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hBCA0000000000001; - zrf = 64'hB57FFFFFFC00000E; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2416089\n"); - end - xrf = 64'hBFCFFFFFFFE003FE; - y = 64'hC190004004000000; - zrf = 64'h02502E98C105274C; - ans = 64'h4170004003F001BF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2416703\n"); - end - xrf = 64'h3FDFFFFFFFFF7000; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h3FE0000000000001; - ans = 64'h3FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2417317\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h683905CF5187CAA5; - zrf = 64'hC030000800000007; - ans = 64'h6B9905CF5187CAA4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2417931\n"); - end - xrf = 64'hCC107FF000000000; - y = 64'hBFD0000000000000; - zrf = 64'h4507B3BFBB78EFE5; - ans = 64'h4BF07FF000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2418545\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hC07002000000003F; - zrf = 64'h8000000000000001; - ans = 64'hC3D002000000003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2419159\n"); - end - xrf = 64'h401000041FFFFFFE; - y = 64'hC34AB555D6DB3D20; - zrf = 64'hB71FF800000007FE; - ans = 64'hC36AB55CB99B5E81; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2419773\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h0010000000000001; - ans = 64'hC33FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2420387\n"); - end - xrf = 64'hC030007FFFFC0000; - y = 64'hBFDFFFFFE07FFFFE; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'h3F4FFC0EE07FE0FA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2421001\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hBFE0000000000000; - zrf = 64'hC1DFC00000000002; - ans = 64'hC34000003F800000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2421615\n"); - end - xrf = 64'h8000000002000000; - y = 64'hFF100001EFFFFFFF; - zrf = 64'h8D261BB2DA873976; - ans = 64'h3D800001EFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2422229\n"); - end - xrf = 64'hC3F0EC7428A39224; + x = 64'hC760000001FFFFF8; y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h43F0EC7428A39223; + z = 64'hBFCFFFFEFFFF7FFE; + ans = 64'h4760000001FFFFF7; rn = 1; rz = 0; rm = 0; @@ -185473,19 +46727,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -185501,12 +46755,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2422843\n"); + $fwrite(fp,"2001915\n"); end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hBCAFFFFFFFFFFF82; - zrf = 64'h0011114A361594FC; - ans = 64'hC00FFFFFFFFFFF81; + x = 64'h43E000000001007F; + y = 64'h3FD2BFF6A883BA1F; + z = 64'h3FC3EFFFFFFFFFFF; + ans = 64'h43C2BFF6A884E6B3; rn = 1; rz = 0; rm = 0; @@ -185520,19 +46774,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -185548,247 +46802,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2423457\n"); + $fwrite(fp,"2003929\n"); end - xrf = 64'h3FD0FBBF78309F71; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h61EFF7FFFFFBFFFF; - ans = 64'h61EFF7FFFFFBFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2424071\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h3FF28976C15F0778; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2424685\n"); - end - xrf = 64'h480FFFFFFFFFFFFF; - y = 64'h3FF42A8ADCFAE94E; - zrf = 64'h418000005FFFFFFE; - ans = 64'h48142A8ADCFAE94D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2425299\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hC35FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2425913\n"); - end - xrf = 64'hC03502AC87DDF103; - y = 64'h3FA5997EC022603A; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC0138BA24EB04DDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2426527\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; + x = 64'h4010000000000000; y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h3B2000010000007F; - ans = 64'hC35FFFFFFFFFFFFD; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -185802,19 +46821,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -185830,152 +46849,246 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2427141\n"); + $fwrite(fp,"2005943\n"); end - xrf = 64'h4026288FEF6695C2; - y = 64'hC032000000000200; - zrf = 64'hC1EF6A05D4EDE99D; - ans = 64'hC1EF6A05EDDB8B8A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2427755\n"); - end - xrf = 64'h4010007FFFFBFFFF; - y = 64'hC000000000000001; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'hC020007FFFFC0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2428369\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hC05FFF7FFFFFBFFE; - zrf = 64'hBFBFFF7FE0000000; - ans = 64'hC3BFFF7FFFFFBFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2428983\n"); - end - xrf = 64'h7FE61B8FDFDDBD73; + x = 64'hD1680001FFFFFFFF; y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'hC7FFF807FFFFFFFF; + z = 64'h3F8FE10000000000; + ans = 64'h51880001FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2007957\n"); + end + x = 64'h1C3FAFFFFFFFFFFE; + y = 64'h5117FFFC00000000; + z = 64'h3FBBBFFFFFFFFFFF; + ans = 64'h3FBBBFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2009971\n"); + end + x = 64'h4010000000000000; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hC03FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2011985\n"); + end + x = 64'hC02000000000FFFF; + y = 64'hC340000000000001; + z = 64'h3FDF3A13972DC395; + ans = 64'h4370000000010000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2013999\n"); + end + x = 64'h3E90000007FFDFFE; + y = 64'hBF9F000000FFFFFF; + z = 64'hDE78A6810C5E2943; + ans = 64'hDE78A6810C5E2943; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2016013\n"); + end + x = 64'h4010000000000000; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hBFF0000000000001; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -185990,19 +47103,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -186018,12 +47131,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2429597\n"); + $fwrite(fp,"2018027\n"); end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h4010000000088000; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; + x = 64'h47F000000FFFFFEF; + y = 64'hFFF0000000000001; + z = 64'h3EC212497B5FBA52; + ans = 64'hFFF8000000000001; rn = 1; rz = 0; rm = 0; @@ -186037,19 +47150,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -186065,12 +47178,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2430211\n"); + $fwrite(fp,"2020041\n"); end - xrf = 64'hC3D000077FFFFFFE; - y = 64'h4760000000103FFF; - zrf = 64'hC02FFFFFFFE00002; - ans = 64'hCB40000780104005; + x = 64'hC2422D50B4254ACC; + y = 64'hC98FFFFBFF7FFFFF; + z = 64'h43B00003FFFFFFFC; + ans = 64'h4BE22D4E6E327F04; rn = 1; rz = 0; rm = 0; @@ -186084,19 +47197,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -186112,11 +47225,152 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2430825\n"); + $fwrite(fp,"2022055\n"); end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hC010000000000000; - zrf = 64'hFFFFFFFFFFFFFFFE; + x = 64'h4010000000000001; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2024069\n"); + end + x = 64'hBFF8F0CC26A49147; + y = 64'h0010000000000000; + z = 64'hBFCFFFBFFFFFFFEF; + ans = 64'hBFCFFFBFFFFFFFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2026083\n"); + end + x = 64'h41C0007FFC000000; + y = 64'h3C4FF80000001FFF; + z = 64'hC49EF96D79F85B02; + ans = 64'hC49EF96D79F85B02; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2028097\n"); + end + x = 64'h4010000000000001; + y = 64'h3CA0000000000001; + z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -186131,19 +47385,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -186159,12 +47413,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2431439\n"); + $fwrite(fp,"2030111\n"); end - xrf = 64'h42D020001FFFFFFF; - y = 64'hCD1D000A016615E8; - zrf = 64'hC000000000000000; - ans = 64'hCFFD3A0A4F68F615; + x = 64'h001000001FFFFF80; + y = 64'h3FD0000000000000; + z = 64'h3FCFF8001FFFFFFF; + ans = 64'h3FCFF8001FFFFFFF; rn = 1; rz = 0; rm = 0; @@ -186178,19 +47432,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -186206,12 +47460,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2432053\n"); + $fwrite(fp,"2032125\n"); end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hBF7FFFFF7FC00000; - ans = 64'hC37FFFFFFFFFFFFE; + x = 64'hE9017BABC578EAC4; + y = 64'hB87FFFFFFE0001FF; + z = 64'hBFD44A66846F7879; + ans = 64'h61917BABC461311F; rn = 1; rz = 0; rm = 0; @@ -186225,19 +47479,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -186253,12 +47507,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2432667\n"); + $fwrite(fp,"2034139\n"); end - xrf = 64'h480F4C07FE7541A5; - y = 64'h3FCFFFFFFF7FFFEE; - zrf = 64'h2DBFFFFBFFBFFFFF; - ans = 64'h47EF4C07FDF81173; + x = 64'h4010000000000001; + y = 64'h3FE0000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h4000000000000002; rn = 1; rz = 0; rm = 0; @@ -186272,19 +47526,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -186300,12 +47554,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2433281\n"); + $fwrite(fp,"2036153\n"); end - xrf = 64'hBFEFFFC00000003F; - y = 64'hC340000000000000; - zrf = 64'h3CA0000000000000; - ans = 64'h433FFFC00000003F; + x = 64'hB80FEFFFFFFFBFFE; + y = 64'h3FF0000000000000; + z = 64'hC7CFFF0000000200; + ans = 64'hC7CFFF0000000200; rn = 1; rz = 0; rm = 0; @@ -186319,19 +47573,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -186347,12 +47601,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2433895\n"); + $fwrite(fp,"2038167\n"); end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hC3EFFDFFFFF80000; - zrf = 64'hAC9E00003FFFFFFF; - ans = 64'hC74FFDFFFFF7FFFF; + x = 64'hC1C1FFFFFFFFFFBF; + y = 64'hC1F20000000007FE; + z = 64'hBEEFDFFFFFFFFFEF; + ans = 64'h43C44000000008B5; rn = 1; rz = 0; rm = 0; @@ -186366,19 +47620,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -186394,12 +47648,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2434509\n"); + $fwrite(fp,"2040181\n"); end - xrf = 64'hB1B00000001001FF; - y = 64'hC340000000000001; - zrf = 64'h3FDFFFFFFFEFFFFC; - ans = 64'h3FDFFFFFFFEFFFFC; + x = 64'h4010000000000001; + y = 64'h4000000000000001; + z = 64'h3FF0000000000001; + ans = 64'h4022000000000002; rn = 1; rz = 0; rm = 0; @@ -186413,19 +47667,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -186441,12 +47695,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2435123\n"); + $fwrite(fp,"2042195\n"); end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'h48000000000000FA; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; + x = 64'h43DC00000FFFFFFF; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h403775BC9C46BBBF; + ans = 64'h43FC00000FFFFFFD; rn = 1; rz = 0; rm = 0; @@ -186460,19 +47714,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -186488,12 +47742,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2435737\n"); + $fwrite(fp,"2044209\n"); end - xrf = 64'hC1F0000000005FFF; - y = 64'hC3D000000007C000; - zrf = 64'h38180000000000FE; - ans = 64'h45D0000000081FFF; + x = 64'h2F82A1B8ACB26B67; + y = 64'h8D400003F7FFFFFE; + z = 64'h3FD1000007FFFFFF; + ans = 64'h3FD1000007FFFFFF; rn = 1; rz = 0; rm = 0; @@ -186507,19 +47761,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -186535,12 +47789,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2436351\n"); + $fwrite(fp,"2046223\n"); end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; + x = 64'h4010000000000001; + y = 64'h4340000000000000; + z = 64'hC340000000000000; + ans = 64'h4358000000000002; rn = 1; rz = 0; rm = 0; @@ -186554,19 +47808,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -186582,12 +47836,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2436965\n"); + $fwrite(fp,"2048237\n"); end - xrf = 64'h44CFFF0001FFFFFE; - y = 64'h39E20528C2077414; - zrf = 64'hBFF0000000000001; - ans = 64'hBFEFFFFB7ED9D98A; + x = 64'hC6500083FFFFFFFF; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h3FDF7FFFFFFFBFFF; + ans = 64'hC9B00083FFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -186601,19 +47855,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -186629,12 +47883,811 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2437579\n"); + $fwrite(fp,"2050251\n"); end - xrf = 64'h434FFFFFFFFFFFFF; + x = 64'h3CE3F7CF953A40DF; + y = 64'h3C3B23C4A3B1C107; + z = 64'h3FD7FFFFFFFFF7FF; + ans = 64'h3FD7FFFFFFFFF7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2052265\n"); + end + x = 64'h4010000000000001; + y = 64'h7FF0000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2054279\n"); + end + x = 64'h2D927E1B4772D416; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hAEC000001FFFFF7F; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2056293\n"); + end + x = 64'h3815633161D11357; + y = 64'h403FFFFF9FFFFFFF; + z = 64'h3FB0000200080000; + ans = 64'h3FB0000200080000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2058307\n"); + end + x = 64'h4010000000000001; + y = 64'h8010000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2060321\n"); + end + x = 64'hC4DFFFFFFFFFFBFB; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h401023FFFFFFFFFE; + ans = 64'h401023FFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2062335\n"); + end + x = 64'h47F422D15FBFC2A7; + y = 64'hC04000001FC00000; + z = 64'h7FDFFEFFFFBFFFFF; + ans = 64'h7FDFFEFFFFBFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2064349\n"); + end + x = 64'h4010000000000001; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000005; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2066363\n"); + end + x = 64'hBF8FFFFFBFFFFFFB; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h7FF7FFFFFFFFFFEF; + ans = 64'h7FFFFFFFFFFFFFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2068377\n"); + end + x = 64'h3FCFFFFFFFFFBFF7; + y = 64'h8000010000020000; + z = 64'hB80000000207FFFF; + ans = 64'hB80000000207FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2070391\n"); + end + x = 64'h4010000000000001; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h433FFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2072405\n"); + end + x = 64'h801FC874B609EF56; + y = 64'hBFF0000000000001; + z = 64'h40FD762D718A93A8; + ans = 64'h40FD762D718A93A8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2074419\n"); + end + x = 64'h3FAFFFFF00040000; + y = 64'h41C000000000007F; + z = 64'h3FB6225DA8DAFEF7; + ans = 64'h417FFFFF016626D9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2076433\n"); + end + x = 64'h4010000000000001; + y = 64'hC00FFFFFFFFFFFFF; + 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,"2078447\n"); + end + x = 64'h3FDFFF80007FFFFF; + y = 64'hC010000000000001; + z = 64'hC000000003FE0000; + ans = 64'hC00FFFC0043E0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2080461\n"); + end + x = 64'hC7EFF38A13C13651; + y = 64'hC02894BC2E1A6C18; + z = 64'hA220000400000000; + ans = 64'h48288B29D23FF2B2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2082475\n"); + end + x = 64'h4010000000000001; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hC370000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2084489\n"); + end + x = 64'h3FB7FFFFBFFFFFFF; y = 64'hFFE0000000000001; - zrf = 64'h400FFFFFFFFFF7EF; - ans = 64'hFFF0000000000000; + z = 64'hC04CF36D5B8ACEE5; + ans = 64'hFFA7FFFFC0000000; rn = 1; rz = 0; rm = 0; @@ -186648,19 +48701,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -186676,12 +48729,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2438193\n"); + $fwrite(fp,"2086503\n"); end - xrf = 64'hB9617FFFFFFFFFFF; - y = 64'hC0183814DE8DA0F4; - zrf = 64'h4650000000208000; - ans = 64'h4650000000208000; + x = 64'h3FB00000000000FD; + y = 64'h3648D98A332E5571; + z = 64'h35080008E5BACA0B; + ans = 64'h3608D9A233373CB5; rn = 1; rz = 0; rm = 0; @@ -186695,19 +48748,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -186723,246 +48776,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2438807\n"); + $fwrite(fp,"2088517\n"); end - xrf = 64'h9870000401FFFFFF; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h0010000000000001; - ans = 64'h5870000401FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2439421\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hBFC00200001FFFFE; - zrf = 64'hC03000000043FFFE; - ans = 64'hC32002000020001D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2440035\n"); - end - xrf = 64'h2E4FFFFFFF8007FF; - y = 64'hFFF0000000000000; - zrf = 64'hC2A04000000FFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2440649\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; - y = 64'hBE21FC0000000000; - zrf = 64'h4340000000000001; - ans = 64'h433FFFFFFDC08002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2441263\n"); - end - xrf = 64'hC1D80000007FFFFF; - y = 64'hBFD00000400000FE; - zrf = 64'h215FEDFFFFFFFFFF; - ans = 64'h41B800006080017E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2441877\n"); - end - xrf = 64'h434FFFFFFFFFFFFF; + x = 64'h4010000000000001; y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hFFE0000000000001; + z = 64'h3FF0000000000001; ans = 64'hFFFFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -186977,19 +48795,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -187005,11 +48823,1515 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2442491\n"); + $fwrite(fp,"2090531\n"); end - xrf = 64'h7FD20000001FFFFE; - y = 64'hFA7FFBFFDFFFFFFE; - zrf = 64'hBFEFFFFFFFFFFFFF; + x = 64'hC3D39F1456976025; + y = 64'h0000000000000000; + z = 64'h7FEFFFFFFF7FFFEF; + ans = 64'h7FEFFFFFFF7FFFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2092545\n"); + end + x = 64'h3FC000000000101F; + y = 64'h4D1684A027E5AE5F; + z = 64'h40300000005FFFFE; + ans = 64'h4CE684A027E5C50F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2094559\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h0010000000000001; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2096573\n"); + end + x = 64'h41B5AFA14B1E5380; + y = 64'h3CA0000000000000; + z = 64'h27B003FFEFFFFFFF; + ans = 64'h3E65AFA14B1E5380; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2098587\n"); + end + x = 64'hBE1FFFF0FFFFFFFF; + y = 64'h3F5FFFFF00000000; + z = 64'h3FCFFFFFFDFBFFFF; + ans = 64'h3FCFFFFFFDFA0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2100601\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h3FD0000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2102615\n"); + end + x = 64'h07FFFFFE0000003F; + y = 64'h3FE0000000000000; + z = 64'h401D1C3F8CA4CDAC; + ans = 64'h401D1C3F8CA4CDAC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2104629\n"); + end + x = 64'hC7FFFF0200000000; + y = 64'hC7E3DFFFFFFFFFFF; + z = 64'h8021FFFFFFFFFBFF; + ans = 64'h4FF3DF623DFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2106643\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h3FF0000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h4020000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2108657\n"); + end + x = 64'hC00FFFFFFFF7BFFE; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hBFD47AFA8ED01F9A; + ans = 64'hC020A3D7D47260FB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2110671\n"); + end + x = 64'h0A6F3FFFFFFFFFFF; + y = 64'hBD50001003FFFFFE; + z = 64'hB2CEF95F6CEEFEB0; + ans = 64'hB2CEF95F6CEEFEB0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2112685\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h4010000000000000; + z = 64'hBFF0000000000001; + ans = 64'h403EFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2114699\n"); + end + x = 64'hB810004000000010; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h403FFF7FFFFFF000; + ans = 64'h403FFF7FFFFFF000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2116713\n"); + end + x = 64'h97F1FFFFFFFFFE00; + y = 64'hC1EEFFFFFFFE0000; + z = 64'h3FF000007FFFFFFC; + ans = 64'h3FF000007FFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2118727\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h7FE0000000000000; + z = 64'h4340000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2120741\n"); + end + x = 64'hBF90B94940132032; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'hFFDFBFFFFFFFDFFF; + ans = 64'hFFE065CA4A008901; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2122755\n"); + end + x = 64'h002FFFFFFFF7BFFF; + y = 64'hB12B2946E3E0CC24; + z = 64'h41AAEA0575638D88; + ans = 64'h41AAEA0575638D88; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2124769\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2126783\n"); + end + x = 64'h4100000800020000; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h5C807FFFFFFEFFFF; + ans = 64'h5C807FFFFFFEFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2128797\n"); + end + x = 64'h41C27972E0EE4B70; + y = 64'h41D0001007FFFFFE; + z = 64'h001000000040000F; + ans = 64'h43A27985639DE5CC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2130811\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2132825\n"); + end + x = 64'hDE8FE003FFFFFFFE; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hC0D20000000007FF; + ans = 64'h5B4FE003FFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2134839\n"); + end + x = 64'hC3CFFBFBFFFFFFFF; + y = 64'h8000100400000000; + z = 64'h480FFFFFEFEFFFFF; + ans = 64'h480FFFFFEFEFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2136853\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'hC007FFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2138867\n"); + end + x = 64'hC34FF80000001000; + y = 64'hBFE0000000000001; + z = 64'hC3FF7EFFFFFFFFFE; + ans = 64'hC3FF7D007FFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2140881\n"); + end + x = 64'h400FDFFE00000000; + y = 64'h4000BEB28AC6E8DF; + z = 64'hC1DF7FFFF8000000; + ans = 64'hC1DF7FFFF5EA41A6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2142895\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC340000000000008; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2144909\n"); + end + x = 64'h4020000000003FBE; + y = 64'hC000000000000001; + z = 64'hC1CFEFFFFFFFFF7F; + ans = 64'hC1CFF00007FFFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2146923\n"); + end + x = 64'hC01FFFFC00001000; + y = 64'h37E02007FFFFFFFE; + z = 64'hC000000040000200; + ans = 64'hC000000040000200; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2148937\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2150951\n"); + end + x = 64'h3FCEB158F9D7DFA5; + y = 64'hC340000000000001; + z = 64'hC34C63CAEBFBFE18; + ans = 64'hC3501CFB059B7D06; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2152965\n"); + end + x = 64'hBF70020000000100; + y = 64'hBFB971827803ECEC; + z = 64'h7FF3422AFCE71F00; + ans = 64'h7FFB422AFCE71F00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2154979\n"); + end + x = 64'h401FFFFFFFFFFFFF; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -187024,19 +50346,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -187052,12 +50374,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2443105\n"); + $fwrite(fp,"2156993\n"); end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h0000000000000000; - zrf = 64'hC3D1DD612FB617A3; - ans = 64'hC3D1DD612FB617A3; + x = 64'h47E00010000FFFFE; + y = 64'hFFF0000000000000; + z = 64'hC3D9B18B35728971; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -187071,19 +50393,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -187099,12 +50421,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2443719\n"); + $fwrite(fp,"2159007\n"); end - xrf = 64'hC3CFDFFFFFFEFFFF; - y = 64'hB7FFDFFFFFFBFFFE; - zrf = 64'h400FFF7FFFFEFFFE; - ans = 64'h400FFF7FFFFEFFFE; + x = 64'hB950003FEFFFFFFE; + y = 64'hB7F4003FFFFFFFFE; + z = 64'h3D90000080000400; + ans = 64'h3D90000080000400; rn = 1; rz = 0; rm = 0; @@ -187118,19 +50440,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -187146,12 +50468,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2444333\n"); + $fwrite(fp,"2161021\n"); end - xrf = 64'h37E0000100004000; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h000FFFFFFFFFFFFF; + x = 64'h401FFFFFFFFFFFFE; + y = 64'h0000000000000001; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; rn = 1; rz = 0; rm = 0; @@ -187165,19 +50487,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -187193,12 +50515,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2444947\n"); + $fwrite(fp,"2163035\n"); end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h3FCFFFFFFFF0007E; - zrf = 64'hB1FFFFFFF0000003; - ans = 64'h432FFFFFFFF0007C; + x = 64'h43FE690733095B3F; + y = 64'h0010000000000000; + z = 64'h9C0CF7EB74A0FE9B; + ans = 64'h9C0CF7EB74A0FE9B; rn = 1; rz = 0; rm = 0; @@ -187212,19 +50534,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -187240,12 +50562,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2445561\n"); + $fwrite(fp,"2165049\n"); end - xrf = 64'h3FF36ED15DD5FF0B; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h40EFDEFFFFFFFFFE; - ans = 64'h40EFDEFFFFFFFFFE; + x = 64'h7FD0D3762DCE7F2B; + y = 64'hC01BFE411C7BC401; + z = 64'hAFBB3A77155F16A8; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -187259,19 +50581,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -187287,12 +50609,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2446175\n"); + $fwrite(fp,"2167063\n"); end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h43D00001FFFFFFFE; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h47300001FFFFFFFD; + x = 64'h401FFFFFFFFFFFFE; + y = 64'h3CA0000000000001; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; rn = 1; rz = 0; rm = 0; @@ -187306,19 +50628,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -187334,12 +50656,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2446789\n"); + $fwrite(fp,"2169077\n"); end - xrf = 64'hC03FE0003FFFFFFF; - y = 64'hB7EFFFF7FFEFFFFF; - zrf = 64'hC000000FF7FFFFFE; - ans = 64'hC000000FF7FFFFFE; + x = 64'hB7E00001FFFFFF00; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'hB800000001FFFFFF; + ans = 64'hB800000001FFFFFF; rn = 1; rz = 0; rm = 0; @@ -187353,19 +50675,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -187381,12 +50703,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2447403\n"); + $fwrite(fp,"2171091\n"); end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h0010000000000001; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFF; + x = 64'hB7FFFE0000000100; + y = 64'h3FBBFFFFFEFFFFFE; + z = 64'h3FB0002000001FFF; + ans = 64'h3FB0002000001FFF; rn = 1; rz = 0; rm = 0; @@ -187400,19 +50722,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -187428,152 +50750,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2448017\n"); + $fwrite(fp,"2173105\n"); end - xrf = 64'hC3C0FFFFFFFFDFFE; - y = 64'hA5900000080003FF; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2448631\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h400FFFFFEFFFFFF7; - ans = 64'h400FFFFFEFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2449245\n"); - end - xrf = 64'h0020000000110000; - y = 64'h6D2F133A7F2809C1; - zrf = 64'hC03000000001FFFC; - ans = 64'hC03000000001FFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2449859\n"); - end - xrf = 64'h3FB1518817833EC0; - y = 64'h3CA0000000000000; - zrf = 64'hFFFFFFFFFFFFFFFE; + x = 64'h401FFFFFFFFFFFFE; + y = 64'h3FE0000000000000; + z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -187588,19 +50769,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -187616,623 +50797,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2450473\n"); + $fwrite(fp,"2175119\n"); end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'hC67FFFFFC0000800; - zrf = 64'h4034000000007FFE; - ans = 64'hC9DFFFFFC00007FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2451087\n"); - end - xrf = 64'h3FCFF00003FFFFFE; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h40396641E9D46149; - ans = 64'h40396641E9D46149; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2451701\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h7FF19D6663608B5D; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h7FF99D6663608B5D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2452315\n"); - end - xrf = 64'h7FDFFFFFFC07FFFF; - y = 64'h41CFFFFC01FFFFFE; - zrf = 64'hCA40001FFFF7FFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2452929\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h3FD0000000000000; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'h432FFFFFFFFFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2453543\n"); - end - xrf = 64'hB7F00003FFFFE000; - y = 64'h3FCF7F2EBA57F364; - zrf = 64'hBFD0000000000000; - ans = 64'hBFD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2454157\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h405C0023F12D5E3D; - ans = 64'h4340000000000037; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2454771\n"); - end - xrf = 64'h7FD004007FFFFFFF; - y = 64'hC020000000008001; - zrf = 64'hC80BDBDBDC204CF5; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2455385\n"); - end - xrf = 64'h480EFB187297B81E; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2455999\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h43F00B8D04784AC1; - zrf = 64'h3FBFFFFFEE000000; - ans = 64'h47500B8D04784AC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2456613\n"); - end - xrf = 64'hCC6FFF8000000001; - y = 64'h3FE0000000000001; - zrf = 64'hBFA27E00240AF10F; - ans = 64'hCC5FFF8000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2457227\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'hC1FFFF0FFFFFFFFF; - zrf = 64'h4000000000000000; - ans = 64'hC55FFF0FFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2457841\n"); - end - xrf = 64'h40AFFFFFFFFFFCFE; - y = 64'h380000000000017F; - zrf = 64'h000E30BD8369AC4B; - ans = 64'h38BFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2458455\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; + x = 64'hC7ED450B577AD8A8; y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'hC010000000000000; - ans = 64'h434FFFFFFFFFFFFA; + z = 64'h41CDEFFFFFFFFFFF; + ans = 64'hC7ED450B577AD8A6; rn = 1; rz = 0; rm = 0; @@ -188246,19 +50816,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -188274,11 +50844,340 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2459069\n"); + $fwrite(fp,"2177133\n"); end - xrf = 64'h7FEFFFFFFEFFFFBF; - y = 64'h401FBFFFFC000000; - zrf = 64'hBCA0000000000001; + x = 64'hC3C03FFFFFFFFBFE; + y = 64'h8DEFFFFE07FFFFFF; + z = 64'hBA5FDFFFFF7FFFFF; + ans = 64'hBA5FDFFFFF7FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2179147\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'h4000000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h402FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2181161\n"); + end + x = 64'h322FFFE004000000; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h400000000400001F; + ans = 64'h400000000400001F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2183175\n"); + end + x = 64'h3FE0000FFFFFFFFC; + y = 64'hBCAE000000001FFE; + z = 64'h0010040000000006; + ans = 64'hBC9E001E00001FF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2185189\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'h4340000000000000; + z = 64'h3FF0000000000001; + ans = 64'h436FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2187203\n"); + end + x = 64'hF02FFFE000000000; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hC1EFBFFFFFFFDFFF; + ans = 64'hF38FFFDFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2189217\n"); + end + x = 64'h40C00007FC000000; + y = 64'hC1CFFFFFF8001FFF; + z = 64'hBF1FFF8000100000; + ans = 64'hC2A00007F8000E01; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2191231\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hC340000000000000; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -188293,19 +51192,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -188321,12 +51220,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2459683\n"); + $fwrite(fp,"2193245\n"); end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h3FF0000000000001; - zrf = 64'hFFD7E4BB7A2E0326; - ans = 64'hFFD7E4BB7A2E0326; + x = 64'hAEADD75F0AEE4DE6; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hBCAFFFFFFE001FFF; + ans = 64'h7FFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -188340,19 +51239,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -188368,12 +51267,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2460297\n"); + $fwrite(fp,"2195259\n"); end - xrf = 64'h45EE2D3BC6E262EA; - y = 64'h37FFFFFFFF7FFEFF; - zrf = 64'h3FD774F0EF62E768; - ans = 64'h3FD774F0EFDB9C57; + x = 64'hC19FDF7FFFFFFFFE; + y = 64'h43DF80003FFFFFFF; + z = 64'hC1C4000000002000; + ans = 64'hC58F60023FBEFFFD; rn = 1; rz = 0; rm = 0; @@ -188387,19 +51286,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -188415,12 +51314,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2460911\n"); + $fwrite(fp,"2197273\n"); end - xrf = 64'h3F3F7FFFF8000000; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; + x = 64'h401FFFFFFFFFFFFE; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -188434,19 +51333,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -188462,12 +51361,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2461525\n"); + $fwrite(fp,"2199287\n"); end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h4C7FFFFFF7FFFFFE; - zrf = 64'hC010000000800100; - ans = 64'h4FDFFFFFF7FFFFFC; + x = 64'hC2700000003FF7FF; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hBDFFFFFE7FFFFFFE; + ans = 64'hBDFFFFFE7FFFFFFE; rn = 1; rz = 0; rm = 0; @@ -188481,19 +51380,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -188509,12 +51408,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2462139\n"); + $fwrite(fp,"2201301\n"); end - xrf = 64'hC010100001000000; - y = 64'h4000000000000000; - zrf = 64'hC07FFFFFFF7FFEFF; - ans = 64'hC080403FFFC3FF80; + x = 64'hC03FFF8200000000; + y = 64'h0A1FFFDFFFFFFFDE; + z = 64'h802CDB4B12FB1438; + ans = 64'h8A6FFF62007DFFDE; rn = 1; rz = 0; rm = 0; @@ -188528,19 +51427,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -188556,12 +51455,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2462753\n"); + $fwrite(fp,"2203315\n"); end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h47EFFFFFFFFF7F80; - zrf = 64'h3FF0000000000001; - ans = 64'h4B4FFFFFFFFF7F7E; + x = 64'h401FFFFFFFFFFFFE; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hBCDBFFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -188575,19 +51474,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -188603,12 +51502,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2463367\n"); + $fwrite(fp,"2205329\n"); end - xrf = 64'h3FCD3AEC7123E6D4; - y = 64'hC040FFFFFFFFFFFF; - zrf = 64'h41700008000FFFFE; - ans = 64'h4170000783D5931D; + x = 64'hC3CFFFFF000003FF; + y = 64'hBFD0000000000001; + z = 64'h05FEAC5FF2C4D343; + ans = 64'h43AFFFFF00000401; rn = 1; rz = 0; rm = 0; @@ -188622,19 +51521,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -188650,12 +51549,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2463981\n"); + $fwrite(fp,"2207343\n"); end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hC000000000000001; - ans = 64'h436FFFFFFFFFFFFD; + x = 64'h3FC013FFFFFFFFFF; + y = 64'h3FC000000FFFFEFE; + z = 64'hBFEDFFFFFFFFDFFF; + ans = 64'hBFED7F5FFF7F4007; rn = 1; rz = 0; rm = 0; @@ -188669,19 +51568,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -188697,12 +51596,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2464595\n"); + $fwrite(fp,"2209357\n"); end - xrf = 64'h270F000000FFFFFF; - y = 64'h41CE3457B589E945; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h28ED42B4F8CF3CB8; + x = 64'h401FFFFFFFFFFFFE; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hC021FFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -188716,19 +51615,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -188744,12 +51643,952 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2465209\n"); + $fwrite(fp,"2211371\n"); end - xrf = 64'h434FFFFFFFFFFFFE; + x = 64'h38D407FFFFFFFFFE; + y = 64'hBFF0000000000001; + z = 64'h47EFFFFFFFDFDFFE; + ans = 64'h47EFFFFFFFDFDFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2213385\n"); + end + x = 64'hBD6800000007FFFF; + y = 64'hC3D8A89C08D5D92C; + z = 64'h4000040000000800; + ans = 64'h41527E7586C68D07; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2215399\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h433FFFFFFFFFFFE0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2217413\n"); + end + x = 64'h5A800000001EFFFF; + y = 64'hC010000000000000; + z = 64'hC02FFFFFE0000010; + ans = 64'hDAA00000001EFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2219427\n"); + end + x = 64'hBFF00080003FFFFF; + y = 64'h401FF81000000000; + z = 64'hB27FFFFF001FFFFF; + ans = 64'hC01FF90FC0FFE03E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2221441\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hC340000000000001; + 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,"2223455\n"); + end + x = 64'h3802000080000000; + y = 64'hFFE0000000000000; + z = 64'h70C9B12F3A1F01C1; + ans = 64'hF7F2000080000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2225469\n"); + end + x = 64'hC010140B934D5FF7; + y = 64'hC03F80000003FFFF; + z = 64'hC00FFFFFFF0FFFFF; + ans = 64'h405EA776CA0BD9F0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2227483\n"); + end + x = 64'h401FFFFFFFFFFFFE; + y = 64'hFFF0000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2229497\n"); + end + x = 64'h3CEFFFFFFFEFFBFF; + y = 64'h0000000000000000; + z = 64'hC800010002000000; + ans = 64'hC800010002000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2231511\n"); + end + x = 64'hBEDD24BCCEE2CCD4; + y = 64'h47E00007FFFFFDFF; + z = 64'h3CAFFFFE003FFFFF; + ans = 64'hC6CD24CB6141309F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2233525\n"); + end + x = 64'h4340000000000000; + y = 64'h0010000000000001; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2235539\n"); + end + x = 64'hC1D000000000203F; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h001FFFFFFFFFF7BF; + ans = 64'h81FFFFFFFF80407C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2237553\n"); + end + x = 64'h7FEFFFC000000800; + y = 64'h001FFFFFFFFFDFBF; + z = 64'h546FFFFF7FFEFFFF; + ans = 64'h546FFFFF7FFEFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2239567\n"); + end + x = 64'h4340000000000000; + y = 64'h3FD0000000000000; + z = 64'hC340000000000000; + ans = 64'hC338000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2241581\n"); + end + x = 64'h3C3FF000FFFFFFFE; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h4570100000007FFF; + ans = 64'h4570100000007FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2243595\n"); + end + x = 64'hB7EFBFFFFFFFFFFF; + y = 64'hC3E0000003FFFDFF; + z = 64'h400FF7E000000000; + ans = 64'h400FF7E000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2245609\n"); + end + x = 64'h4340000000000000; + y = 64'h3FF0000000000000; + 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,"2247623\n"); + end + x = 64'h3FF00008007FFFFE; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hCC60001FFFFDFFFF; + ans = 64'hCC60001FFFFDFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2249637\n"); + end + x = 64'h3FEBFFFFFFDFFFFE; + y = 64'hC3B0080000000FFF; + z = 64'hC3F0000002000002; + ans = 64'hC3F0E07001FF0062; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2251651\n"); + end + x = 64'h4340000000000000; y = 64'h4010000000000000; - zrf = 64'hC03FFBFFF0000000; - ans = 64'h436FFFFFFFFFFFFA; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h4360000000000000; rn = 1; rz = 0; rm = 0; @@ -188763,19 +52602,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -188791,12 +52630,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2465823\n"); + $fwrite(fp,"2253665\n"); end - xrf = 64'hC3D00003FEFFFFFF; - y = 64'hB7EFFFFFFFFFF001; - zrf = 64'h3FF0400000000001; - ans = 64'h3FF0400000000001; + x = 64'h41F00000FC000000; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h4366FE581A30B534; + ans = 64'h4366FE591A30C4F4; rn = 1; rz = 0; rm = 0; @@ -188810,19 +52649,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -188838,12 +52677,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2466437\n"); + $fwrite(fp,"2255679\n"); end - xrf = 64'h78B000000203FFFF; - y = 64'h4010000000000001; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'h78D0000002040000; + x = 64'h3FDFFFFFFF7FFDFE; + y = 64'h3FC0000009FFFFFE; + z = 64'hA44718752C69A512; + ans = 64'h3FB0000009BFFEFD; rn = 1; rz = 0; rm = 0; @@ -188857,19 +52696,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -188885,294 +52724,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2467051\n"); + $fwrite(fp,"2257693\n"); end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h41CFFFF3FFFFFFFF; - zrf = 64'h38FFFFFFFFFFFF82; - ans = 64'h452FFFF3FFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2467665\n"); - end - xrf = 64'hBFF76194103CAB16; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hFFE0BFFFFFFFFFFE; - ans = 64'hFFE0BFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2468279\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h401003FEFFFFFFFF; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h437003FEFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2468893\n"); - end - xrf = 64'hC1000F8D71DACA50; - y = 64'h7BD00000000047FF; - zrf = 64'h434836306FD629E2; - ans = 64'hFCE00F8D71DB1295; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2469507\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h4340000000000001; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'h46A0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2470121\n"); - end - xrf = 64'h8BC20000000001FE; - y = 64'h47F0000FFFFDFFFF; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h93C20011FFFDC1FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2470735\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; + x = 64'h4340000000000000; y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hC01E007FFFFFFFFF; - ans = 64'h46AFFFFFFFFFFFFC; + z = 64'hBFF0000000000001; + ans = 64'h469FFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -189186,19 +52743,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -189214,11 +52771,4852 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2471349\n"); + $fwrite(fp,"2259707\n"); end - xrf = 64'hC34FFFFFFFFFFC00; + x = 64'hC149A213672520D5; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h43400000003FF7FF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2261721\n"); + end + x = 64'h47EFFFFF7FBFFFFF; + y = 64'hC000007FFFFFFFE0; + z = 64'hFFEFFFFFFFFFF7BF; + ans = 64'hFFEFFFFFFFFFF7BF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2263735\n"); + end + x = 64'h4340000000000000; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2265749\n"); + end + x = 64'h3FD34FB8606858F1; + y = 64'h8000000000000001; + z = 64'h0010000000F80000; + ans = 64'h0010000000F80000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2267763\n"); + end + x = 64'hC33FFFFFFF7FFBFE; + y = 64'h402C8FCD7FBF0B36; + z = 64'h400003FFFFFFF7FE; + ans = 64'hC37C8FCD7F4CC86C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2269777\n"); + end + x = 64'h4340000000000000; + y = 64'h801FFFFFFFFFFFFF; + 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,"2271791\n"); + end + x = 64'hC7F49BB4F2B51C99; + y = 64'hBCA0000000000001; + z = 64'h3F9337227034EFC6; + ans = 64'h44A49BB4F2B51C9A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2273805\n"); + end + x = 64'hC7F000001FFFBFFE; + y = 64'h406E708B91074D66; + z = 64'hE5015B4D0390A03B; + ans = 64'hE5015B4D0390A03B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2275819\n"); + end + x = 64'h4340000000000000; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hC32FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2277833\n"); + end + x = 64'h4D07FFFFFFFFFF7F; + y = 64'hBFE0000000000001; + z = 64'hBFF2B6D73D069A54; + ans = 64'hCCF7FFFFFFFFFF80; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2279847\n"); + end + x = 64'h9F4EE4BEA2031544; + y = 64'hD8E0000200FFFFFE; + z = 64'hBFEFFFF00FFFFFFF; + ans = 64'hBFEFFFF00FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2281861\n"); + end + x = 64'h4340000000000000; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'hC34FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2283875\n"); + end + x = 64'h801000FFDFFFFFFF; + y = 64'hC000000000000000; + z = 64'h41BFFFFFE0004000; + ans = 64'h41BFFFFFE0004000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2285889\n"); + end + x = 64'h000FF90000000000; + y = 64'h80206152B561929D; + z = 64'hB6FFFFFFFFFBFFFD; + ans = 64'hB6FFFFFFFFFBFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2287903\n"); + end + x = 64'h4340000000000000; + y = 64'hC010000000000001; + z = 64'hC340000000000000; + ans = 64'hC364000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2289917\n"); + end + x = 64'h80200004000003FE; + y = 64'hC340000000000000; + z = 64'h5B11C4D28BC5C118; + ans = 64'h5B11C4D28BC5C118; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2291931\n"); + end + x = 64'h644FFFFFEFFFFF7E; + y = 64'hC02FEFFFFFFFEFFE; + z = 64'h3CA0000000FF7FFF; + ans = 64'hE48FEFFFF007EF7C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2293945\n"); + end + x = 64'h4340000000000000; + y = 64'hFFE0000000000001; + 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,"2295959\n"); + end + x = 64'h47F15827436BE817; + y = 64'hFFF0000000000000; + z = 64'hBFB64253798AD5C5; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2297973\n"); + end + x = 64'hBCA00007EFFFFFFF; + y = 64'h3F1000000000037F; + z = 64'h001000000040007E; + ans = 64'hBBC00007F000037E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2299987\n"); + end + x = 64'h4340000000000001; + y = 64'h0000000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2302001\n"); + end + x = 64'h7FE3795AF4A2B560; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h0020008000200000; + ans = 64'h4003795AF4A2B55E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2304015\n"); + end + x = 64'h434F8DA321556224; + y = 64'hC01B2588E50183BE; + z = 64'h427142EFD04A8C6B; + ans = 64'hC37AC473219328A3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2306029\n"); + end + x = 64'h4340000000000001; + y = 64'h3CA0000000000000; + z = 64'hBFF0000000000001; + ans = 64'h0000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2308043\n"); + end + x = 64'h00114508BDE544E1; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h800010000003FFFE; + ans = 64'h800010000003FFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2310057\n"); + end + x = 64'h4000001000000020; + y = 64'hC1F1000000000004; + z = 64'h6A4FFFFFFFDFFFF7; + ans = 64'h6A4FFFFFFFDFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2312071\n"); + end + x = 64'h4340000000000001; + y = 64'h3FE0000000000000; + z = 64'h4340000000000000; + ans = 64'h4348000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2314085\n"); + end + x = 64'hBFD0000000004FFF; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hB570000003FFFEFE; + ans = 64'hBFD0000000004FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2316099\n"); + end + x = 64'h3F8B17D321454789; + y = 64'h3FD7FFFFFFFFFF7F; + z = 64'hBFE000080FFFFFFE; + ans = 64'hBFDFAEC8A69C3027; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2318113\n"); + end + x = 64'h4340000000000001; + y = 64'h3FFFFFFFFFFFFFFE; + 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,"2320127\n"); + end + x = 64'h3FB0008020000000; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h61EC0300875AF1DE; + ans = 64'h61EC0300875AF1DE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2322141\n"); + end + x = 64'hBA800007FFDFFFFF; + y = 64'hC02FFFFEFFFFFFFF; + z = 64'hCB5005366E0E9CD9; + ans = 64'hCB5005366E0E9CD9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2324155\n"); + end + x = 64'h4340000000000001; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h4370000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2326169\n"); + end + x = 64'h47B0001FFFDFFFFF; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h3F0FFFFFFFFFFFD7; + ans = 64'h4B10001FFFDFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2328183\n"); + end + x = 64'h3FF0078000000000; + y = 64'h42B13867492E71C0; + z = 64'hC15FFFFFFC0000FE; + ans = 64'h42B140793998BF95; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2330197\n"); + end + x = 64'h4340000000000001; + y = 64'h7FEFFFFFFFFFFFFE; + 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,"2332211\n"); + end + x = 64'h403F840000000000; + y = 64'h7FF0000000000001; + z = 64'h47E00FFFFFFE0000; + 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,"2334225\n"); + end + x = 64'hC1EFFFFFFBFFFFBF; + y = 64'h41EFF99F4885A23D; + z = 64'hC3CFFFE000000001; + ans = 64'hC3F3FCCBA243370A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2336239\n"); + end + x = 64'h4340000000000001; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2338253\n"); + end + x = 64'h3808AD94B0AE8803; + y = 64'h8010000000000001; + z = 64'h40E00100000007FF; + ans = 64'h40E00100000007FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2340267\n"); + end + x = 64'h43D4346A89A9C97B; + y = 64'hBFFBFFFFFFFFFFBF; + z = 64'hFFF959CBE947EE04; + ans = 64'hFFF959CBE947EE04; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2342281\n"); + end + x = 64'h4340000000000001; + y = 64'hBCAFFFFFFFFFFFFF; + 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,"2344295\n"); + end + x = 64'h26986A27B483BA39; + y = 64'hBFD0000000000001; + z = 64'h4030000000000700; + ans = 64'h4030000000000700; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2346309\n"); + end + x = 64'hCA7FFF0000000FFF; + y = 64'h3CA62FD739ECE5A5; + z = 64'h48000000003F0000; + ans = 64'h47FFFE9D0E224CCE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2348323\n"); + end + x = 64'h4340000000000001; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2350337\n"); + end + x = 64'hCECBF0857C72A5F5; + y = 64'hBFF0000000000000; + z = 64'hBCE01000FFFFFFFF; + ans = 64'h4ECBF0857C72A5F5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2352351\n"); + end + x = 64'h43D003FFFFFFFFEF; + y = 64'h37F0800000000080; + z = 64'h4050200000003FFE; + ans = 64'h4050200000003FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2354365\n"); + end + x = 64'h4340000000000001; + y = 64'hC000000000000001; + z = 64'hBFF0000000000001; + ans = 64'hC350000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2356379\n"); + end + x = 64'hC00FFBFDFFFFFFFE; + y = 64'hC010000000000000; + z = 64'h3EEF7BB95B77143E; + ans = 64'h402FFBFFF7BB95B5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2358393\n"); + end + x = 64'hFFDDD23FE56E05F5; + y = 64'h41E008003FFFFFFF; + z = 64'hBF4BB3E839E09DEE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2360407\n"); + end + x = 64'h4340000000000001; + y = 64'hC340000000000001; + z = 64'h4340000000000000; + ans = 64'hC690000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2362421\n"); + end + x = 64'hF29DFFFFFFBFFFFF; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h3FDFFFFC1FFFFFFF; + ans = 64'h75FDFFFFFFBFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2364435\n"); + end + x = 64'hC531EAD9646C686E; + y = 64'hB97FFFFFF80001FF; + z = 64'h89CFFFFFC0003FFF; + ans = 64'h3EC1EAD95FF1B333; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2366449\n"); + end + x = 64'h4340000000000001; + y = 64'hFFF0000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2368463\n"); + end + x = 64'h3FE00000000C0000; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h40400000007FFFFB; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2370477\n"); + end + x = 64'h7FEFFFFFFF9FFFFF; + y = 64'hBA60000000FFFFDF; + z = 64'h3FFFBFFBFFFFFFFF; + ans = 64'hFA60000000CFFFDE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2372491\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h0010000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2374505\n"); + end + x = 64'h401385F7A9AF5663; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hC0D00000003FFF7F; + ans = 64'hC0D00000003FFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2376519\n"); + end + x = 64'hC03FFFE07FFFFFFE; + y = 64'hC0C87EC3854317EF; + z = 64'hC23400016ADF210A; + ans = 64'hC233FFFB4B3446EB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2378533\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h3FD0000000000000; + z = 64'h3FF0000000000001; + ans = 64'h4330000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2380547\n"); + end + x = 64'hBFD0003FFFFFFFBF; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hC800000000003F7F; + ans = 64'hC800000000003F7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2382561\n"); + end + x = 64'h3CA02000000001FF; + y = 64'h7FDFFF8000020000; + z = 64'h3B052E2A4593433B; + ans = 64'h7C901FBF800103FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2384575\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'h433FFFFFFFFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2386589\n"); + end + x = 64'hC1F0001FFFFF7FFE; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h4020000000043FFF; + ans = 64'hC200001FFFBF7FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2388603\n"); + end + x = 64'h40BFFFFFFFFFFFFF; + y = 64'hB7AFFFEFFDFFFFFF; + z = 64'hBFCFFC0000007FFF; + ans = 64'hBFCFFC0000007FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2390617\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2392631\n"); + end + x = 64'hE53B5D1CE7BB1B34; + y = 64'h401FFFFFFFFFFFFF; + z = 64'hC800800000000100; + ans = 64'hE56B5D1CE7BB1B33; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2394645\n"); + end + x = 64'h42A0020000000007; + y = 64'hBDAFE01FFFFFFFFF; + z = 64'h3FF000000021FFFF; + ans = 64'hC05FA41C03FF780D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2396659\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h46AFFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2398673\n"); + end + x = 64'h40469EBFECE9387D; + y = 64'h7FE0000000000001; + z = 64'h381C686C04250688; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2400687\n"); + end + x = 64'h400C1D1B46E04D2B; + y = 64'hBE4E00000000001F; + z = 64'hC02F7FFF00000000; + ans = 64'hC02F7FFF01A5B499; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2402701\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2404715\n"); + end + x = 64'h4017FFFFBFFFFFFF; + y = 64'h8000000000000001; + z = 64'hFFDFFFDFFFFFF7FF; + ans = 64'hFFDFFFDFFFFFF7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2406729\n"); + end + x = 64'hBC1C9A8F60BA2EC4; + y = 64'h413000000020FFFF; + z = 64'h3FE0000E00000000; + ans = 64'h3FE0000DFFFFF1B3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2408743\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2410757\n"); + end + x = 64'hC2400FFFFFFFFF7F; + y = 64'hBCA0000000000000; + z = 64'h4017FFFFFFFFFFF7; + ans = 64'h4018000403FFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2412771\n"); + end + x = 64'h7F600000FBFFFFFF; + y = 64'hC024153A49A4352E; + z = 64'hB2A0000000200002; + ans = 64'hFF94153B85F28B35; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2414785\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hBFD0000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2416799\n"); + end + x = 64'hC1FFFFFFFFFF3FFF; + y = 64'hBFE0000000000000; + z = 64'hC01FFFFFFFE00000; + ans = 64'h41EFFFFFFEFF3FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2418813\n"); + end + x = 64'h3ECFFFFFFFFE0000; + y = 64'h3FC0FFF800000000; + z = 64'hC0D00010000007FE; + ans = 64'hC0D0000FFFFDE7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2420827\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hBFF0000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hC350000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2422841\n"); + end + x = 64'hBCC0103FFFFFFFFF; + y = 64'hC000000000000000; + z = 64'hB810010004000000; + ans = 64'h3CD0103FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2424855\n"); + end + x = 64'hBFDC000000080000; + y = 64'hBFBFFFFFFFFFEFE0; + z = 64'hC035EDB781F59599; + ans = 64'hC035DFB781F591A0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2426869\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hC010000000000001; + z = 64'h3FF0000000000001; + ans = 64'hC370000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2428883\n"); + end + x = 64'h00026CC69D542DC6; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h41F0000000000001; + ans = 64'h41F0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2430897\n"); + end + x = 64'h47BCAE5548D2EC6C; + y = 64'h8020FA9C6893D5B3; + z = 64'hC0300000000FFFBF; + ans = 64'hC0300000000FFFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2432911\n"); + end + x = 64'h434FFFFFFFFFFFFF; + y = 64'hFFE0000000000000; + z = 64'hC340000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2434925\n"); + end + x = 64'hC000731E440CDC60; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hF10FFFFFFFFFFE7F; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2436939\n"); + end + x = 64'h3D3647E2D0587670; + y = 64'hBEC000000007DFFF; + z = 64'h206FFFFFFFF7FBFF; + ans = 64'hBC0647E2D0636DD0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2438953\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h0000000000000000; + 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,"2440967\n"); + end + x = 64'hB62FFFFE00400000; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hB7300003FFFFFFFF; + ans = 64'hB7300003FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2442981\n"); + end + x = 64'h4482000FFFFFFFFF; + y = 64'h495FFFFFFEFFFFFF; + z = 64'hBFE917F807D49DAF; + ans = 64'h4DF2000FFF6FFF7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2444995\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h3CA0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2447009\n"); + end + x = 64'hC06321EC0ECEF83A; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h43DFFFFFFFEFFF7F; + ans = 64'h43DFFFFFFFEFFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2449023\n"); + end + x = 64'hEE9FFDFFFFF7FFFF; + y = 64'hC6C000000000F800; + z = 64'hC386807C8536E615; + ans = 64'h756FFDFFFFF9EFE0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2451037\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'h433FFFFFFFFFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2453051\n"); + end + x = 64'hC7F7BED1D818FB7C; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hBFF0000000900000; + ans = 64'hC7F7BED1D818FB7B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2455065\n"); + end + x = 64'h6FBFFFFFFFFFFCFF; + y = 64'hC020000008000100; + z = 64'hAC62001000000000; + ans = 64'hEFF0000007FFFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2457079\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h4363FFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2459093\n"); + end + x = 64'h0C1A68326C1E35DC; + y = 64'h4000000000000001; + z = 64'h7FE00000FFFFFFF0; + ans = 64'h7FE00000FFFFFFF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2461107\n"); + end + x = 64'hC3FAF80EB5114084; + y = 64'h0003D852E11515F0; + z = 64'h3D9FFFEFFFFFE000; + ans = 64'h3D9FFFEFFFFFE000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2463121\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'h401FFFFFFFFFFFFF; + 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,"2465135\n"); + end + x = 64'h3FF998BCFCA42C40; + y = 64'h4340000000000001; + z = 64'h47E487C0C983E604; + ans = 64'h47E487C0C983E604; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2467149\n"); + end + x = 64'hC34FFFFFFFFFFC00; y = 64'hBBE000000000027F; - zrf = 64'h43DFFFFFEFFFFBFF; + z = 64'h43DFFFFFEFFFFBFF; ans = 64'h43DFFFFFEFFFFBFF; rn = 1; rz = 0; @@ -189233,19 +57631,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -189261,12 +57659,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2471963\n"); + $fwrite(fp,"2469163\n"); end - xrf = 64'h381E94E42BF42E17; - y = 64'h7FE0000000000000; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'h780E94E42BF42E17; + x = 64'h434FFFFFFFFFFFFE; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -189280,19 +57678,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -189308,12 +57706,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2472577\n"); + $fwrite(fp,"2471177\n"); end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'hC0600000021FFFFF; - zrf = 64'h387007FFFFFFFFFA; - ans = 64'hC3C00000021FFFFE; + x = 64'hC7EFFB7FFFFFFFFF; + y = 64'h7FF0000000000001; + z = 64'h41D0003FFFFFFFC0; + ans = 64'h7FF8000000000001; rn = 1; rz = 0; rm = 0; @@ -189327,19 +57725,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -189357,10 +57755,10 @@ initial if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); $fwrite(fp,"2473191\n"); end - xrf = 64'hC1FFFFFFFE1FFFFE; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hB7FFFFFFFBFFFFBF; - ans = 64'hFFF0000000000000; + x = 64'h800FFFFFFDFFFFFF; + y = 64'hBFCFFE00003FFFFE; + z = 64'h800FFFF01FFFFFFE; + ans = 64'h800C00302077F7FF; rn = 1; rz = 0; rm = 0; @@ -189374,19 +57772,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -189402,5793 +57800,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2473805\n"); + $fwrite(fp,"2475205\n"); end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h766C7FFFFFFFFFFE; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h79CC7FFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2474419\n"); - end - xrf = 64'hC34FFFFFFFFFFC07; - y = 64'hB810000200001000; - zrf = 64'hC7A000000000004E; - ans = 64'hC7A000000000004E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2475033\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h7FF0000000000000; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2475647\n"); - end - xrf = 64'hBFEFE00008000000; - y = 64'hCE7000FFFFFBFFFE; - zrf = 64'h8000000000000000; - ans = 64'h4E6FE1FE07F887FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2476261\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h40DFFFFC00020000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2476875\n"); - end - xrf = 64'h2CFFFFFFEE000000; - y = 64'hBCAFFFFFFBFFFF80; - zrf = 64'hE29FFFFE000FFFFF; - ans = 64'hE29FFFFE000FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2477489\n"); - end - xrf = 64'h3C70000001FFFFFA; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'hC010000000000000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2478103\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h417F8000000003FF; - zrf = 64'h41CFFFFFFFFDFFFF; - ans = 64'h44DF80000000040D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2478717\n"); - end - xrf = 64'hBC0FF000000007FF; - y = 64'h8000000000000001; - zrf = 64'h40BFFFFDFFFFBFFF; - ans = 64'h40BFFFFDFFFFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2479331\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'hC28FFFFFFFC00000; - zrf = 64'h3FD0000000000000; - ans = 64'hC5EFFFFFFFBFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2479945\n"); - end - xrf = 64'hBFA080FFFFFFFFFF; - y = 64'h3D14FE4D81C77FAF; - zrf = 64'h3FC0C75B734A8881; - ans = 64'h3FC0C75B734A886B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2480559\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2481173\n"); - end - xrf = 64'h000000001FEFFFFF; - y = 64'hC01FF80000000000; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2481787\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h8010000000000001; - zrf = 64'h4030003FFFFDFFFF; - ans = 64'h4030003FFFFDFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2482401\n"); - end - xrf = 64'hD8A00004003FFFFF; - y = 64'h3F3FFFEF7FFFFFFF; - zrf = 64'hFFE008000000FFFE; - ans = 64'hFFE008000000FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2483015\n"); - end - xrf = 64'hC1F0003EFFFFFFFF; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'hC000000000000001; - ans = 64'hC000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2483629\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h47F2990F0D3AB431; - zrf = 64'h393D2F8E7A9FABB8; - ans = 64'h4B52990F0D3AB430; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2484243\n"); - end - xrf = 64'h403000003FBFFFFF; - y = 64'hBCA0000000000000; - zrf = 64'hB81E0000001FFFFE; - ans = 64'hBCE000003FBFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2484857\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'hC04FF800000003FF; - zrf = 64'h3CA0000000000001; - ans = 64'hC3AFF800000003FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2485471\n"); - end - xrf = 64'hBF0C50CD67902869; - y = 64'h403BFFC000000000; - zrf = 64'h40A04000007FFFFF; - ans = 64'h40A03FFF3A4C2737; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2486085\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'hBFD0000000000001; - ans = 64'hC010FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2486699\n"); - end - xrf = 64'hFFDFBBFFFFFFFFFE; - y = 64'hBE9FFFFFF80007FF; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2487313\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'hBFD0000000000000; - zrf = 64'hC1F0000080001000; - ans = 64'hC3300001000007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2487927\n"); - end - xrf = 64'hC03FFBFFEFFFFFFE; - y = 64'hBD21FFFFFFFFFDFF; - zrf = 64'h43EF800040000000; - ans = 64'h43EF800040000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2488541\n"); - end - xrf = 64'hB7F0000000024000; - y = 64'hBFD0000000000001; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2489155\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h000F800001FFFFFE; - zrf = 64'h47F00000007F8000; - ans = 64'h47F00000007F8000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2489769\n"); - end - xrf = 64'h7FE244C23A3D6EAE; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h9B2FFFFFFFFFEDFF; - ans = 64'hFFD244C23A3D6EAD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2490383\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h4FA9881599BF1A5B; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h5309881599BF1A59; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2490997\n"); - end - xrf = 64'h381FFFFFFFFFDEFF; - y = 64'h49CFBFF7FFFFFFFF; - zrf = 64'h3FE898FF0DEE5590; - ans = 64'h41FFBFF8000C2BC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2491611\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'hBFE0000000000001; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2492225\n"); - end - xrf = 64'hC0303FFFFFFFFE00; - y = 64'h7FDFFFFFEF7FFFFF; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2492839\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hBFBDFFFFFFFFFFDE; - ans = 64'hC34FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2493453\n"); - end - xrf = 64'h3CA2DEE9CC137D78; - y = 64'hC340000000008000; - zrf = 64'h3C4A51233EDE3650; - ans = 64'hBFF2DEE9CC14146F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2494067\n"); - end - xrf = 64'hC01C622D64A3288A; - y = 64'hBFF0000000000000; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'h4018622D64A3288A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2494681\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h4030002000FFFFFE; - zrf = 64'h6C6000000007F800; - ans = 64'h6C6000000007F800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2495295\n"); - end - xrf = 64'h97938A198628AFDE; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h3CA1FFFFFFFFDFFF; - ans = 64'h3CA1FFFFFFFFDFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2495909\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h499FFFFFFFFEFFFE; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h4CFFFFFFFFFEFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2496523\n"); - end - xrf = 64'hBFB71435A3DCB677; - y = 64'hBFBFFFF7FFFFFF7F; - zrf = 64'hC0503FFF7FFFFFFE; - ans = 64'hC0503F46DE810984; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2497137\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'hC000000000000000; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'hC35FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2497751\n"); - end - xrf = 64'hC033F17FAAA569B5; - y = 64'hC34EFFFFFFFFFFDE; - zrf = 64'h4340000000000000; - ans = 64'h4393D1F3AD503E52; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2498365\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h801FFFFFFFF7FFBE; - ans = 64'hC36FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2498979\n"); - end - xrf = 64'h4B82DA79B78A7C5C; - y = 64'hFFF8F12536538EFF; - zrf = 64'hC01FFC0000000100; - ans = 64'hFFF8F12536538EFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2499593\n"); - end - xrf = 64'hBB7F4BAC4BBA9910; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2500207\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h401FC147E4167F25; - zrf = 64'h407B43BA65F2A73B; - ans = 64'h437FC147E4167F3E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2500821\n"); - end - xrf = 64'hBFDDD9E98A3D34F9; - y = 64'hC010000000000001; - zrf = 64'hC3DD470895062963; - ans = 64'hC3DD470895062963; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2501435\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h7FEFBFFFF7FFFFFF; - zrf = 64'h0000000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2502049\n"); - end - xrf = 64'hC3FFFFFF000FFFFF; - y = 64'h7FF07FFFFFFE0000; - zrf = 64'h43CFFFFFFFFFDFFE; - ans = 64'h7FF87FFFFFFE0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2502663\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h8010000000000000; - ans = 64'hC37FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2503277\n"); - end - xrf = 64'h7FF0000000FFBFFF; - y = 64'hA9A0001FFFFFFFF8; - zrf = 64'h4010000000000001; - ans = 64'h7FF8000000FFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2503891\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'hC340000000000001; - zrf = 64'hBCA3FFFFFFFF7FFE; - ans = 64'hC6A0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2504505\n"); - end - xrf = 64'h3D00800000000002; - y = 64'hC06FFFFFE00003FF; - zrf = 64'hB81CC3048B84E23F; - ans = 64'hBD807FFFEF800211; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2505119\n"); - end - xrf = 64'h434FE0000007FFFF; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hBFD0000000000001; - ans = 64'hC6AFE0000007FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2505733\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'hFFDFFEFEFFFFFFFF; - zrf = 64'h399D95938DB130F5; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2506347\n"); - end - xrf = 64'h43FF0AD19973161F; - y = 64'hFFE0000000000000; - zrf = 64'h41E0000000002FFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2506961\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'hC00FEFFFFFFFFDFF; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2507575\n"); - end - xrf = 64'hBFC000107FFFFFFF; - y = 64'h380FBFFFFFFFFDFF; - zrf = 64'h43403FFFFFFF8000; - ans = 64'h43403FFFFFFF8000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2508189\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h8000000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2508803\n"); - end - xrf = 64'hC0500003FFFFFEFE; - y = 64'hC2311EB7C65185DC; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h42911EBC0DFF865C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2509417\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'hFFF0000000000000; - zrf = 64'h90DFFFFFC3FFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2510031\n"); - end - xrf = 64'hC1D866C6E8E78AA0; - y = 64'hBE0E00000007FFFF; - zrf = 64'hC0EFFFFEFFFFFFBE; - ans = 64'hC0EFFFD13F4B0B00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2510645\n"); - end - xrf = 64'h001FFC000000FFFE; - y = 64'hFFF0000000000001; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2511259\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h364FFFFFF807FFFF; - zrf = 64'h400FFFFFFBFFFBFF; - ans = 64'h400FFFFFFBFFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2511873\n"); - end - xrf = 64'h7FEBFFDFFFFFFFFE; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h5A0FFFFEFFFF7FFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2512487\n"); - end - xrf = 64'h434FFFFFFFFFFFFE; - y = 64'h497FFBFFFEFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2513101\n"); - end - xrf = 64'hAC2000000200003E; - y = 64'h418FFFFDFFFFFBFF; - zrf = 64'h001FBFFFFFEFFFFF; - ans = 64'hADBFFFFE03FFFC3B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2513715\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h0000000000000001; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2514329\n"); - end - xrf = 64'h001FFFFFFFFFFFE6; - y = 64'hC00FEFDFFFFFFFFF; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h3FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2514943\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hC0200005FFFFFFFF; - ans = 64'hC018000BFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2515557\n"); - end - xrf = 64'h59F0000040003FFE; - y = 64'hC010003800000000; - zrf = 64'h57C1FEFFFFFFFFFF; - ans = 64'hDA10003840009007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2516171\n"); - end - xrf = 64'hC3CFC00800000000; - y = 64'h0010000000000000; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h83EFC00800000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2516785\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'hC03508327EAAA217; - zrf = 64'h3F700400000003FF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2517399\n"); - end - xrf = 64'h2838382127EC1F47; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hC42FFFFC00000001; - ans = 64'hC42FFFFC00000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2518013\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h4B70000000400800; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2518627\n"); - end - xrf = 64'h3FFF1FFFFFFFFFFF; - y = 64'h4140000000FFFFEE; - zrf = 64'h400FFFFFFFE1FFFE; - ans = 64'h414F200201F1FFDA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2519241\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h3CA0000000000000; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2519855\n"); - end - xrf = 64'hBD2002FFFFFFFFFF; - y = 64'h802989E4FD4682E9; - zrf = 64'h3FF0000000000000; - ans = 64'h3FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2520469\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h47E8C5BFE3AE8110; - ans = 64'h7C9FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2521083\n"); - end - xrf = 64'hC0300000001FFFBF; - y = 64'h398FFFFEFFFFF800; - zrf = 64'hBEF00001FFFBFFFF; - ans = 64'hBEF00001FFFBFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2521697\n"); - end - xrf = 64'hC025AA627143737D; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h8010000000000000; - ans = 64'hBCE5AA627143737C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2522311\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h43C0000003F7FFFE; - zrf = 64'hC800000004000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2522925\n"); - end - xrf = 64'hBFFFFFFFF7FFFFFE; - y = 64'h3FD0000000000001; - zrf = 64'hC7E55EFA4B05F9A4; - ans = 64'hC7E55EFA4B05F9A4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2523539\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h43F000080001FFFE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2524153\n"); - end - xrf = 64'hB80103FFFFFFFFFF; - y = 64'h3FDE95FBB84960D4; - zrf = 64'h401FFFFF8FFFFFFF; - ans = 64'h401FFFFF8FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2524767\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE8000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2525381\n"); - end - xrf = 64'hC02DFBFFFFFFFFFF; - y = 64'hCAADFFFFFFFFFFDF; - zrf = 64'h3FE0000000000001; - ans = 64'h4AEC1C3FFFFFFFE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2525995\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h3FE0000000000000; - zrf = 64'h9A30ABB2E44153EF; - ans = 64'h7FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2526609\n"); - end - xrf = 64'h3DC0CBF5120273C1; - y = 64'hBFDFFC0000000002; - zrf = 64'hBFDEFFFFFFFFFFFE; - ans = 64'hBFDF000000043275; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2527223\n"); - end - xrf = 64'hCA7FEFF7FFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h8000000000000001; - ans = 64'hCA7FEFF7FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2527837\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'hC03FFFF9FFFFFFFE; - zrf = 64'h3D5FFFFFFFFB7FFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2528451\n"); - end - xrf = 64'h3FE002FFFFFFFFFF; - y = 64'h3FF0000000000000; - zrf = 64'hC050000000010003; - ans = 64'hC04FBFF400020006; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2529065\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'hC78FFFFE000003FF; - zrf = 64'hC010000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2529679\n"); - end - xrf = 64'h402FF7FDFFFFFFFE; - y = 64'hCC7FEFFFFFFFF800; - zrf = 64'h41C001000000003F; - ans = 64'hCCBFE80200FFF800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2530293\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h4340000000000001; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2530907\n"); - end - xrf = 64'h401AF433A5C310C2; - y = 64'hFFFF000000001000; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'hFFFF000000001000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2531521\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hC02000000000040E; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2532135\n"); - end - xrf = 64'hC1F000F000000000; - y = 64'hB80000800001FFFF; - zrf = 64'h3FC8304279FDE7F0; - ans = 64'h3FC8304279FDE7F0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2532749\n"); - end - xrf = 64'h4000000080001000; - y = 64'h4000000000000001; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2533363\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h4095FFFFFFFFFFFF; - zrf = 64'h43DDFFFFFFF7FFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2533977\n"); - end - xrf = 64'h47E00000000083FF; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hA81F7FFFFFFFFFFE; - ans = 64'h48000000000083FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2534591\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'hBFAC9D7B95393F9A; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hFF9C9D7B95393F9A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2535205\n"); - end - xrf = 64'h47FD53F8480209BD; - y = 64'h5B10000000003FE0; - zrf = 64'h3818000000000006; - ans = 64'h631D53F848027ED2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2535819\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h4010000000000001; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2536433\n"); - end - xrf = 64'h402000040003FFFE; - y = 64'h3FFA36685A1C57E1; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h402A366EE7BCFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2537047\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h41DFFDFFFFFFFFFC; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2537661\n"); - end - xrf = 64'h41E7FFFFFFFFFBFF; - y = 64'h4003FFFEFFFFFFFE; - zrf = 64'h44C0000003BFFFFF; - ans = 64'h44C0000003C000EF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2538275\n"); - end - xrf = 64'hC00FFFFFFFDFFFF0; - y = 64'h4340000000000000; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2538889\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h3C60DB966C536079; - zrf = 64'hC05FFFFFE8000000; - ans = 64'h7C50DB966C536079; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2539503\n"); - end - xrf = 64'hC5F00001007FFFFE; - y = 64'h4340000000000001; - zrf = 64'hBFF56B74EF72E498; - ans = 64'hC9400001007FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2540117\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h43D00000081FFFFF; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2540731\n"); - end - xrf = 64'h48BFFFEFFFDFFFFF; - y = 64'hC0EFFFFFFFF9FFFF; - zrf = 64'hC3E7DFFFFFFFFFFF; - ans = 64'hC9BFFFEFFFDA0001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2541345\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h7FE0000000000000; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2541959\n"); - end - xrf = 64'h3FE0002000000040; - y = 64'h3FEC0ABDA0188AA0; - zrf = 64'h3CA0000000000000; - ans = 64'h3FDC0AF5B593CB43; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2542573\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h7FE0000000000001; - zrf = 64'hC3EA2ECD4C6AACA2; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2543187\n"); - end - xrf = 64'h402FFFFFFFFFBF80; - y = 64'h3FFFFFF00FFFFFFF; - zrf = 64'h403462A60FA855C0; - ans = 64'h404A314B0FD40AA0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2543801\n"); - end - xrf = 64'h47E0000800001FFE; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h7FE0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2544415\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h41BFFDFFFFFFBFFF; - zrf = 64'h3FF0040000800000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2545029\n"); - end - xrf = 64'h43F84175528AF1B9; - y = 64'h7FF0000000000000; - zrf = 64'h00134D6087A330D2; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2545643\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'hB7EF4D5D25A022C2; - zrf = 64'hBFF0000000000000; - ans = 64'hF7DF4D5D25A022C2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2546257\n"); - end - xrf = 64'hBB0FB893E0DECB72; - y = 64'hC1CFFFF7FFBFFFFF; - zrf = 64'hC03FFC0000003FFF; - ans = 64'hC03FFC0000003FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2546871\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h4000000000000000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2547485\n"); - end - xrf = 64'h476020000FFFFFFF; - y = 64'h37E01FFFFFBFFFFE; - zrf = 64'h0010000000000001; - ans = 64'h3F5040400FDF7FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2548099\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h8000000000000000; - zrf = 64'hD011287150AEFD43; - ans = 64'hD011287150AEFD43; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2548713\n"); - end - xrf = 64'h4D64A98A03D930E9; - y = 64'hBFEFFFF000003FFF; - zrf = 64'hC03E000008000000; - ans = 64'hCD64A97FAF14584F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2549327\n"); - end - xrf = 64'hB140008000000FFF; + x = 64'h434FFFFFFFFFFFFE; y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; rn = 1; rz = 0; rm = 0; @@ -195202,19 +57819,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -195230,12 +57847,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2549941\n"); + $fwrite(fp,"2477219\n"); end - xrf = 64'h7FE0000000000000; - y = 64'hC3500000040003FF; - zrf = 64'hA54FFFFFFFFF801F; - ans = 64'hFFF0000000000000; + x = 64'hC017FF8000000000; + y = 64'h8010000000000000; + z = 64'hBFCFFFFFFF820000; + ans = 64'hBFCFFFFFFF820000; rn = 1; rz = 0; rm = 0; @@ -195249,19 +57866,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -195277,12 +57894,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2550555\n"); + $fwrite(fp,"2479233\n"); end - xrf = 64'h403FFFFEFFFFFDFF; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'hC3EFFFFFF7FFEFFF; - ans = 64'hC3EFFFFFF7FFEFFF; + x = 64'hCAEBFFFFFFFFFF7F; + y = 64'h43C5000000000000; + z = 64'hBFB00003FFFDFFFE; + ans = 64'hCEC25FFFFFFFFFAB; rn = 1; rz = 0; rm = 0; @@ -195296,19 +57913,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -195324,18482 +57941,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2551169\n"); + $fwrite(fp,"2481247\n"); end - xrf = 64'h7FE0000000000000; - y = 64'hC1D0020000000003; - zrf = 64'hBFE0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2551783\n"); - end - xrf = 64'h207FFFFFFFFFFF07; - y = 64'hBFE000000000401F; - zrf = 64'hB7E0040FFFFFFFFF; - ans = 64'hB7E0040FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2552397\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h3FF0000000000001; - ans = 64'hC007FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2553011\n"); - end - xrf = 64'hBFB7539AB7055255; - y = 64'hB7F07FFFFFFC0000; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h37B80E378CB7A801; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2553625\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h41CFFFE0007FFFFF; - ans = 64'h41CFFFDFFE7FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2554239\n"); - end - xrf = 64'hB0BFFFFFF8000000; - y = 64'hC039090F6427704A; - zrf = 64'h37FCC8AD640425EC; - ans = 64'h37FCC8AD640425EC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2554853\n"); - end - xrf = 64'hC1FA7A8D6AE07DA3; + x = 64'h434FFFFFFFFFFFFE; y = 64'hBCA0000000000001; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h402000001A7A8D6A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2555467\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'hBFAFFFFFFFF80001; - zrf = 64'hA370000000008006; - ans = 64'hFF9FFFFFFFF80001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2556081\n"); - end - xrf = 64'hBF141E8D0C4FEF1D; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h43FFFE00000001FF; - ans = 64'h43FFFE00000001FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2556695\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h4E401FFFFFFFFBFE; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2557309\n"); - end - xrf = 64'h3FE2E1C5E52BB3A1; - y = 64'hC3F0004100000000; - zrf = 64'h402FFFFE0003FFFF; - ans = 64'hC3E2E2129A5FA6A3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2557923\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'hBFD0000000000001; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'hFFC0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2558537\n"); - end - xrf = 64'h3895AD9CB6F014AE; - y = 64'h48E00000003FF7FF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2559151\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h43DBFDFA22D31748; - ans = 64'hFFCFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2559765\n"); - end - xrf = 64'hCB5FFF000FFFFFFE; - y = 64'hBEBBFE0000000000; - zrf = 64'hFFD397BE63CB741C; - ans = 64'hFFD397BE63CB741C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2560379\n"); - end - xrf = 64'hB810002002000000; - y = 64'hBFE0000000000000; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2560993\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h40000000000017FF; - zrf = 64'h3FE8000000000080; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2561607\n"); - end - xrf = 64'h407FFFFF00003FFF; - y = 64'hBFE0000000000001; - zrf = 64'h247FFFEFFFFFFFFB; - ans = 64'hC06FFFFF00004001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2562221\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h434FFFFFFFF8007F; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2562835\n"); - end - xrf = 64'h3CAFFFDFFFFFFFF8; - y = 64'h4036FF793EA8AA59; - zrf = 64'hC3F615879A14A987; - ans = 64'hC3F615879A14A987; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2563449\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'hBFF0000000000000; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2564063\n"); - end - xrf = 64'hA6F004000000001F; - y = 64'h3800000000000FF7; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2564677\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'hBFF0000000000001; - zrf = 64'hBFCFFFFFFFFFFC07; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2565291\n"); - end - xrf = 64'hC04000001FF7FFFF; - y = 64'hFD2FFFBFFFF7FFFF; - zrf = 64'h40100000000007EF; - ans = 64'h7D7FFFC03FE7801D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2565905\n"); - end - xrf = 64'h3E5EFFFFFFDFFFFF; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h4000000000000000; - ans = 64'h3FFFFFFFF0800000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2566519\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'hBFE000040000000E; - zrf = 64'hA21FFE00000FFFFF; - ans = 64'hFFD000040000000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2567133\n"); - end - xrf = 64'h3F00200000000000; - y = 64'hC000000000000000; - zrf = 64'h3F7FFFEFFFF80000; - ans = 64'h3F7FBF6FFFF80000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2567747\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h7FE3F4CB8A40190A; - zrf = 64'hBCA0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2568361\n"); - end - xrf = 64'h3CA007EFFFFFFFFE; - y = 64'h79400001FFFDFFFF; - zrf = 64'h3F300000008007FE; - ans = 64'h75F007F200FBFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2568975\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h3FD0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2569589\n"); - end - xrf = 64'h3FEFFFFFFDBFFFFF; - y = 64'h3FE0808805F24554; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2570203\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'hC010000000000000; - zrf = 64'hC1F00FFFFDFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2570817\n"); - end - xrf = 64'h3FFFFFFF7FFFE000; - y = 64'hC8003FFFFFFFFFFB; - zrf = 64'hEB6FFFFFFFFFF3FF; - ans = 64'hEB6FFFFFFFFFF3FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2571431\n"); - end - xrf = 64'h45200001FF7FFFFF; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h3FF0000000000001; - ans = 64'hC5500001FF7FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2572045\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h7FEFFFFFEEFFFFFF; - zrf = 64'hBF3FFFFFDFFFFDFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2572659\n"); - end - xrf = 64'h000FFFDFFFFFFF00; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hC3FA99119A2842A6; - ans = 64'hC3FA99119A2842A6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2573273\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h3FC0000000080003; - zrf = 64'h8010000000000001; - ans = 64'h7FB0000000080003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2573887\n"); - end - xrf = 64'hBF70017FFFFFFFFF; - y = 64'h4C9F9B8BEED274A1; - zrf = 64'h381FF80007FFFFFF; - ans = 64'hCC1F9E8283F0D85A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2574501\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h3CA0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2575115\n"); - end - xrf = 64'hFFDFFF7FFF7FFFFF; - y = 64'h40FFFFFFFFFFFFBE; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2575729\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hCE2FFFFF00001FFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2576343\n"); - end - xrf = 64'h38010000FFFFFFFF; - y = 64'h2B2FBFFFFFFC0000; - zrf = 64'hC3F000000000FE00; - ans = 64'hC3F000000000FE00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2576957\n"); - end - xrf = 64'hB84FFFE040000000; - y = 64'hFFE0000000000001; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h783FFFE040000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2577571\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'h4343A027130C87B4; - zrf = 64'h80000000000001DF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2578185\n"); - end - xrf = 64'h47FFFFFFDFFFFFE0; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h00004003FFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2578799\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'hBFDCD7EBDC5A0408; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'hFFCCD7EBDC5A0408; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2579413\n"); - end - xrf = 64'hFFEFFFFFFFFE0400; - y = 64'hBF2000FBFFFFFFFF; - zrf = 64'h3E8401FFFFFFFFFF; - ans = 64'h7F2000FBFFFF01EF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2580027\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'hFFF0000000000001; - zrf = 64'h001FFFFFFFFFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2580641\n"); - end - xrf = 64'hC08FFFFFFFFF7FDE; - y = 64'h43D09DCF5E6E7F53; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC4709DCF5E6E3CCA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2581255\n"); - end - xrf = 64'h7FE0000000000000; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hC00FFFFFFFC0003F; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2581869\n"); - end - xrf = 64'h3EE03F0000000000; - y = 64'hB818459D897A9352; - zrf = 64'h3FF0001FF7FFFFFF; - ans = 64'h3FF0001FF7FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2582483\n"); - end - xrf = 64'hC03FFFFFFFFFF810; - y = 64'h0000000000000000; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2583097\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h43CEC1D751CCA01A; - zrf = 64'h449A27D1BF4384DC; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2583711\n"); - end - xrf = 64'h48000FFFFFFFFDFF; - y = 64'h0000000000000001; - zrf = 64'h22DFFFFFF83FFFFF; - ans = 64'h22DFFFFFF83FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2584325\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hB7FC2CB5D458BDC2; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2584939\n"); - end - xrf = 64'hFFEFFFFFFFFF7F7E; - y = 64'hC0F5EDD88E0E7D5D; - zrf = 64'hBEDDD10872C31AB9; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2585553\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h0010000000000000; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h4000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2586167\n"); - end - xrf = 64'h301AF9D2D5A4BA0D; - y = 64'hC7FFDFFFFFFFFFFC; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2586781\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h0010000000000001; - zrf = 64'hFFD000000003FC00; - ans = 64'hFFD000000003FC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2587395\n"); - end - xrf = 64'h401903F79E80A3D6; - y = 64'h4003A3DBDB0C18E4; - zrf = 64'hC34002001FFFFFFE; - ans = 64'hC34002001FFFFFF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2588009\n"); - end - xrf = 64'h434FFFFFEFFFEFFE; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h3FD0000000000000; - ans = 64'h3FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2588623\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hC1C7559F1A1AD753; - zrf = 64'hBBE000000FFFFF00; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2589237\n"); - end - xrf = 64'h7FE0FFFFFFFF7FFF; - y = 64'h3CA0000000000000; - zrf = 64'h43CF7D67F6C113D7; - ans = 64'h7C90FFFFFFFF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2589851\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h3EFFFFFF80100000; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2590465\n"); - end - xrf = 64'h3DF88E3F2C57962B; - y = 64'h41EFFE00007FFFFF; - zrf = 64'hFFF00000200001FF; - ans = 64'hFFF80000200001FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2591079\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h0000000000000000; - ans = 64'h7CA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2591693\n"); - end - xrf = 64'h4A00000003FFE000; - y = 64'h43E5972BA17D5A64; - zrf = 64'hC000000000000001; - ans = 64'h4DF5972BA6E2FA1E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2592307\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h3FD0000000000000; - zrf = 64'hBFE28124FEC4E8F9; - ans = 64'h7FC0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2592921\n"); - end - xrf = 64'h5C700006FFFFFFFF; - y = 64'hC3C88EB3A3479B67; - zrf = 64'h8010000000001FDE; - ans = 64'hE0488EBE61B632D5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2593535\n"); - end - xrf = 64'hC3F4D646CE330C0B; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h3CA0000000000001; - ans = 64'hC3E4D646CE330C0A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2594149\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hC1FFFFFFFFFF0000; - zrf = 64'hCEC03FFFFFFF7FFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2594763\n"); - end - xrf = 64'h47EFF07FFFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h3A3FFFFFFFFF9FFE; - ans = 64'h47DFF07FFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2595377\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h3D7FC86542A6B145; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000001FC9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2595991\n"); - end - xrf = 64'h9B4FDFFFFFFFFFFB; - y = 64'h41FFFFFFFEEFFFFF; - zrf = 64'h4FEFFF0000000080; - ans = 64'h4FEFFF0000000080; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2596605\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h3FE0000000000001; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2597219\n"); - end - xrf = 64'h78BFFFFFBFFFFDFF; - y = 64'h002001FBFFFFFFFE; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2597833\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h3CA0001FFFFFFFBF; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2598447\n"); - end - xrf = 64'h3800000007FFFFFE; - y = 64'hB7FFFFFFF80003FF; - zrf = 64'h43D58662EFB06D82; - ans = 64'h43D58662EFB06D82; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2599061\n"); - end - xrf = 64'hC0FEFFFFDFFFFFFF; - y = 64'h3FF0000000000001; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'hC0FEFFFFE0000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2599675\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hE54FE00FFFFFFFFF; - zrf = 64'hC1E721896DA410CA; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2600289\n"); - end - xrf = 64'h800000000E000000; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h034FFFF80FFFFFFE; - ans = 64'h034FFFF80FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2600903\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hC03F800007FFFFFF; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2601517\n"); - end - xrf = 64'hC3DFFFFFFFEFEFFF; - y = 64'h380CD67FF96631CD; - zrf = 64'hBFF001FFFFFFDFFF; - ans = 64'hBFF001FFFFFFDFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2602131\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h4000000000000000; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'h7CB8000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2602745\n"); - end - xrf = 64'hBFCFF80000FFFFFE; - y = 64'h434FFFFD7FFFFFFF; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hC32FF7FD819FFFEB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2603359\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h59303FFFF7FFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2603973\n"); - end - xrf = 64'hC37FFFFEFFFFFFFF; - y = 64'h40C00000000BFFFE; - zrf = 64'h47FFFFFF7FFFFFF7; - ans = 64'h47FFFFFF7FFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2604587\n"); - end - xrf = 64'h19AC61120CE93DEC; - y = 64'h4010000000000000; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h19CC61120CE93DEC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2605201\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hBFC20000000001FE; - zrf = 64'h41DFFFC00007FFFF; - ans = 64'hFFB20000000001FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2605815\n"); - end - xrf = 64'hBFE000007FFFFF00; - y = 64'h4010000000000001; - zrf = 64'h7FD0000000002000; - ans = 64'h7FD0000000002000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2606429\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h7FF00003FFFFFFFD; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h7FF80003FFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2607043\n"); - end - xrf = 64'h41EFFFFFEFFFFFC0; - y = 64'hBF0FFFF00003FFFE; - zrf = 64'h3C94001FFFFFFFFE; - ans = 64'hC10FFFEFF00407BE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2607657\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2608271\n"); - end - xrf = 64'hC010040000FFFFFF; - y = 64'hC0D1FFFFFFFFC000; - zrf = 64'hBFE0000000000000; - ans = 64'h40F20478011FBFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2608885\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h4340000000000001; - zrf = 64'h400F00001FFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2609499\n"); - end - xrf = 64'h3CAFFFFFF7FF0000; - y = 64'hC0A069D658AB80BD; - zrf = 64'h400FC0000000003F; - ans = 64'h400FBFFFFFFFFC25; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2610113\n"); - end - xrf = 64'h38000FFEFFFFFFFE; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h0000000000000000; - ans = 64'h3B600FFEFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2610727\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hBEAFFFF0000001FF; - zrf = 64'h3500000000000FF8; - ans = 64'hFE9FFFF000000201; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2611341\n"); - end - xrf = 64'hC06FFFF800000010; - y = 64'h7FE0000000000000; - zrf = 64'hC1DF1F5FFFC2803A; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2611955\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h400020001FFFFFFF; - zrf = 64'h4010000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2612569\n"); - end - xrf = 64'hAE56D8F6C524E8AD; - y = 64'hC030000060000000; - zrf = 64'h4340000000000002; - ans = 64'h4340000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2613183\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2613797\n"); - end - xrf = 64'hC3E54C4A34BFA6E4; - y = 64'hBFC00000FFFFFBFF; - zrf = 64'hBFD0000000000001; - ans = 64'h43B54C4B898444DC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2614411\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h7FF0000000000000; - zrf = 64'h002FFF800001FFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2615025\n"); - end - xrf = 64'hC0103FF800000000; - y = 64'h434007FFFFFFEFFF; - zrf = 64'hBC70000FFFFFFFF7; - ans = 64'hC3604817FBFFEFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2615639\n"); - end - xrf = 64'hBF2175E0432D769D; - y = 64'h7FF0000000000001; - zrf = 64'hFFF0000000000001; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2616253\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hB8040179B06430AA; - zrf = 64'h43E0000000800400; - ans = 64'hF7F40179B06430AB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2616867\n"); - end - xrf = 64'h401EFFFFFFFFFFF7; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'hC00FFFFBFFFBFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2617481\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h80200004FFFFFFFF; - zrf = 64'h4000000000000001; - ans = 64'hC0000009FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2618095\n"); - end - xrf = 64'h37EFFF7FF7FFFFFF; - y = 64'h3EB87964ABACA6C6; - zrf = 64'hC014000000080000; - ans = 64'hC014000000080000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2618709\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h8000000000000001; - zrf = 64'hC010000000000001; - ans = 64'hC010000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2619323\n"); - end - xrf = 64'h37FFFFDFFFFE0000; - y = 64'h47F23D7F24A38646; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h40023D6CE7233DCA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2619937\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'hBED0003F7FFFFFFE; - ans = 64'hC00000020007EFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2620551\n"); - end - xrf = 64'h215F7FFFBFFFFFFE; - y = 64'h3960000100000001; - zrf = 64'hC7EFFFFBFEFFFFFF; - ans = 64'hC7EFFFFBFEFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2621165\n"); - end - xrf = 64'hC071FFFFFF7FFFFE; - y = 64'h8010000000000000; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2621779\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hC0200000FDFFFFFF; - zrf = 64'h4053FDFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2622393\n"); - end - xrf = 64'hC7FFFFFFE0000010; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'hBF2F800000000001; - ans = 64'hBF2F800000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2623007\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h801000000001FEFF; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'hBDCFF00800000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2623621\n"); - end - xrf = 64'h3800FFFFFFFFF800; - y = 64'h000FBC0000000000; - zrf = 64'h40DFEFFFFFFFFFF0; - ans = 64'h40DFEFFFFFFFFFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2624235\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hBCA0000000000000; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hFC90000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2624849\n"); - end - xrf = 64'h31BFFFFFE003FFFF; - y = 64'h41EAFA4764C7E465; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h33BAFA4749D0FC48; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2625463\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h7FEFFFFFDFFFFFFC; - ans = 64'h7FEFFFFFDFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2626077\n"); - end - xrf = 64'hFFFFFFFDFFFFFFF7; - y = 64'hC02FF00FFFFFFFFF; - zrf = 64'h3FBFFFFFBFFDFFFF; - ans = 64'hFFFFFFFDFFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2626691\n"); - end - xrf = 64'hBFAFF7FFFFFE0000; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2627305\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hC02001FFFFFFFFFE; - zrf = 64'h3810000000000DFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2627919\n"); - end - xrf = 64'h001AE1C1BB5B4FDA; - y = 64'hBFD0000000000001; - zrf = 64'hC17FFFFFFFFFFFCF; - ans = 64'hC17FFFFFFFFFFFCF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2628533\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hC24E00000000001F; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2629147\n"); - end - xrf = 64'h30E1539D6F604313; - y = 64'h415427C6462AF0E6; - zrf = 64'h4038BBB7881BC9D8; - ans = 64'h4038BBB7881BC9D8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2629761\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hFFD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2630375\n"); - end - xrf = 64'h37EFFFFFFFFDFF7E; - y = 64'hBFAFFFFFFFFFD000; - zrf = 64'h8010000000000000; - ans = 64'hB7AFFFFFFFFDCF7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2630989\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hBFE0000000000001; - zrf = 64'h40332E5BBB9E9819; - ans = 64'hFFD0000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2631603\n"); - end - xrf = 64'h396E5358D2C85AD4; - y = 64'hBFDFEFFFFFFFFFFF; - zrf = 64'hBFDFC03FFFFFFFFE; - ans = 64'hBFDFC03FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2632217\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hC340000000000000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2632831\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hF4500000007FFF7E; - zrf = 64'h380FFFF800100000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2633445\n"); - end - xrf = 64'h40340001FFFFFFFE; - y = 64'hBFF0000000000000; - zrf = 64'hC1D0080000001FFF; - ans = 64'hC1D008000500207F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2634059\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hFFE19967615D1CE2; - zrf = 64'h3FE0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2634673\n"); - end - xrf = 64'hC000000002000100; - y = 64'hB7F0002000000000; - zrf = 64'h402002000000000F; - ans = 64'h402002000000000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2635287\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'hBFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2635901\n"); - end - xrf = 64'hD240007FFFFEFFFF; - y = 64'hBFCFFFEFFFF80000; - zrf = 64'h8000000000000001; - ans = 64'h52200077FFBAFFE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2636515\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hC000000000000000; - zrf = 64'h08D127F5978046FD; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2637129\n"); - end - xrf = 64'hBCE00005FFFFFFFF; - y = 64'h462000003FFFFFFE; - zrf = 64'hEFF00020001FFFFF; - ans = 64'hEFF00020001FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2637743\n"); - end - xrf = 64'h40236D3BE6BA89EE; - y = 64'hC000000000000001; - zrf = 64'hC010000000000001; - ans = 64'hC0376D3BE6BA89EF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2638357\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h37FFFF7FF7FFFFFE; - zrf = 64'h41F0B0E6E43095BE; - ans = 64'h77EFFF7FF8000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2638971\n"); - end - xrf = 64'h41F000000FFF7FFF; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h3FE000100000003E; - ans = 64'hC21000000FFD7FFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2639585\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hC1F91E2D92C9A9B5; - zrf = 64'h3FD0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2640199\n"); - end - xrf = 64'hC5D0000000880000; - y = 64'h428FFFFFFBFFFDFE; - zrf = 64'h3F60FFFFFFFFFDFF; - ans = 64'hC86FFFFFFD0FFDFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2640813\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hC010000000000001; - zrf = 64'hBFE0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2641427\n"); - end - xrf = 64'hBFDFA132CC5B63C1; - y = 64'h402039FAE3724F00; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2642041\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hA84EFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2642655\n"); - end - xrf = 64'hBFBFFFDFDFFFFFFE; - y = 64'h8010047FFFFFFFFF; - zrf = 64'h7FFFFFFFFFFBFFF0; - ans = 64'h7FFFFFFFFFFBFFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2643269\n"); - end - xrf = 64'hC800000020000000; - y = 64'hC340000000000000; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'h4B50000020000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2643883\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hC01FFFEFFFFFFF7E; - zrf = 64'h400FFFF800000080; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2644497\n"); - end - xrf = 64'hFFEFFFDFFFFFFFC0; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hB7FFFF0000200000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2645111\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hC06003BFFFFFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2645725\n"); - end - xrf = 64'h37EB6092B4D1A495; - y = 64'h43600FFFFFFFFF7F; - zrf = 64'h4024003FFFFFFFFE; - ans = 64'h4024003FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2646339\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hFFE0000000000000; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2646953\n"); - end - xrf = 64'h555E597CBADF25DC; - y = 64'hBFB0000002FFFFFE; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2647567\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h000DC2A2A032E095; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2648181\n"); - end - xrf = 64'h0BB273916840FDDD; - y = 64'hBFD07FFFFFFFFF7E; - zrf = 64'h37E0020000800000; - ans = 64'h37E0020000800000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2648795\n"); - end - xrf = 64'h801179AC2F89FF18; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'h4002F3585F13FE2F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2649409\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h3FFFFFDFFFFFDFFE; - zrf = 64'h401F80000000001F; - ans = 64'h7FEFFFDFFFFFE000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2650023\n"); - end - xrf = 64'h3CAAF64D41610A74; - y = 64'hFFF0000000000001; - zrf = 64'hBF900000007FEFFF; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2650637\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'h401512D5D6AFD92E; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2651251\n"); - end - xrf = 64'hC024007FFFFFFFFF; - y = 64'h3E4001000000003E; - zrf = 64'hC1DFFFFF00010000; - ans = 64'hC1DFFFFF00010000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2651865\n"); - end - xrf = 64'h7FE0000000000001; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2652479\n"); - end - xrf = 64'h3810001000000002; - y = 64'hFFDFFFF0000001FF; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2653093\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h0000000000000001; - zrf = 64'h37FFFFFF7FFFFEFF; - ans = 64'h3CCFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2653707\n"); - end - xrf = 64'h3CA0000000400040; - y = 64'h000BFFFFFFFBFFFE; - zrf = 64'h4260000002000000; - ans = 64'h4260000002000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2654321\n"); - end - xrf = 64'hC1EA26D0FBE678F4; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'hBFF0000000000000; - ans = 64'hBFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2654935\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hC3EFF69E32A24625; - zrf = 64'hBF88000800000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2655549\n"); - end - xrf = 64'hC800000003F7FFFF; - y = 64'h0010000000000000; - zrf = 64'h47F92CC74CE08C7C; - ans = 64'h47F92CC74CE08C7C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2656163\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h3C0C7E4BEEEA4147; - zrf = 64'h0010000000000000; - ans = 64'h7C0C7E4BEEEA4146; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2656777\n"); - end - xrf = 64'h45A0000800000020; - y = 64'h3F9D5B14C2083A69; - zrf = 64'h439EFDFFFFFFFFFE; - ans = 64'h454D5B2373725BA8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2657391\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hBCA0000000000000; - ans = 64'h401FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2658005\n"); - end - xrf = 64'h000DFF0000000000; - y = 64'hC0800002FFFFFFFF; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2658619\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h3CA0000000000000; - zrf = 64'hE1BFFFFFFC1FFFFF; - ans = 64'h7C9FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2659233\n"); - end - xrf = 64'hC8C608DD8889617B; - y = 64'h3FDFFFFFFFEFFFE0; - zrf = 64'h3FD0000000000000; - ans = 64'hC8B608DD887E5CF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2659847\n"); - end - xrf = 64'h3FEFFFFFFFFBFFFD; - y = 64'h3CA0000000000001; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2660461\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hC1F33BC4DC616C1F; - zrf = 64'hC010000000001040; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2661075\n"); - end - xrf = 64'h89D00800000007FF; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h41CF3D7795756252; - ans = 64'h41CF3D7795756252; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2661689\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h41CFDFDFFFFFFFFE; - zrf = 64'h0000000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2662303\n"); - end - xrf = 64'h46640000000001FE; - y = 64'h7FDDFFFFFFFFF7FF; - zrf = 64'hC1E000001FFFFF80; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2662917\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h3FD0000000000001; - zrf = 64'h8010000000000001; - ans = 64'h7FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2663531\n"); - end - xrf = 64'h402D74C2FBFA1FDB; - y = 64'h47F000000020FFFE; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h482D74C2FC36E0A9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2664145\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h41F0007FFFC00000; - ans = 64'h7FDFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2664759\n"); - end - xrf = 64'h13601FDFFFFFFFFE; - y = 64'hC1D00000000201FF; - zrf = 64'h43DEC9C680E70DAB; - ans = 64'h43DEC9C680E70DAB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2665373\n"); - end - xrf = 64'hC34F87FB54D961A0; - y = 64'h3FE0000000000000; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hC33F87FB54D961A0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2665987\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hC13FBFFFFFFFFFFC; - zrf = 64'h9E0007FEFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2666601\n"); - end - xrf = 64'h608000000080FFFE; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'hBE5FFFFFFEFFFFF7; - ans = 64'h608000000080FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2667215\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hB81FFFFDFFFFFFFE; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2667829\n"); - end - xrf = 64'hC1FFFFFFFFFE4000; - y = 64'hBFEFFF0007FFFFFE; - zrf = 64'h402FFFFFFFFFFF7F; - ans = 64'h41FFFF0008FE400C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2668443\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h3FF0000000000000; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2669057\n"); - end - xrf = 64'h405DFFFFFFFFBFFF; - y = 64'hBFC37916008602E8; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'hC02C830940FAF78E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2669671\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h47EFFFFFFFFEFFBF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2670285\n"); - end - xrf = 64'h800FFDFFFFFFEFFE; - y = 64'h3FF81FFFFFFFFFFF; - zrf = 64'h1261EBCAEBB0E94A; - ans = 64'h1261EBCAEBB0E94A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2670899\n"); - end - xrf = 64'hD0300004001FFFFF; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hD0400004001FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2671513\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hC7E0000001FFBFFF; - zrf = 64'h9E2FFFFFFFFFF87F; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2672127\n"); - end - xrf = 64'hC3DFFFFFFFFBFFFB; - y = 64'h4000000000000001; - zrf = 64'hB81FA9628B39210C; - ans = 64'hC3EFFFFFFFFBFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2672741\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h7FDA01B736DBF682; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2673355\n"); - end - xrf = 64'h403EFFFFFFFF8000; - y = 64'h40D000008FFFFFFF; - zrf = 64'h3E205EB8191C94FC; - ans = 64'h411F000116FF801F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2673969\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2674583\n"); - end - xrf = 64'h8D100009FFFFFFFE; - y = 64'hBF791618C4CC930D; - zrf = 64'h4000000000000000; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2675197\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h4010000000000001; - zrf = 64'hC3EFFFDFE0000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2675811\n"); - end - xrf = 64'h2E6FFFFFE2000000; - y = 64'h47E00FFFFFFFFFF8; - zrf = 64'hBFEF00000003FFFE; - ans = 64'hBFEF00000003FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2676425\n"); - end - xrf = 64'h6C9FE000007FFFFE; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hBCA0000000000000; - ans = 64'h6CCFE000007FFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2677039\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h40E00000000003F0; - zrf = 64'hC1C401FFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2677653\n"); - end - xrf = 64'hC34FFFF8FFFFFFFF; - y = 64'h4340000000000000; - zrf = 64'h381FFFFFFEFFFFFA; - ans = 64'hC69FFFF8FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2678267\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hDC0F7FFFDFFFFFFF; - zrf = 64'hFFE0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2678881\n"); - end - xrf = 64'h5BA89D8E76702695; - y = 64'h403FFBFFFFFFDFFF; - zrf = 64'h402007FFFFFFFFFC; - ans = 64'h5BF89A7AC4A13FF2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2679495\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2680109\n"); - end - xrf = 64'hC02FFFFDFFFFBFFF; - y = 64'hBFAFFFFDFFFF8000; - zrf = 64'h3FF0000000000001; - ans = 64'h3FFFFFFDFFFFB001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2680723\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h7FE0000000000000; - zrf = 64'h402FE00001FFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2681337\n"); - end - xrf = 64'hFFF0007FFFFFFFF0; - y = 64'hC1CFFFDFFEFFFFFF; - zrf = 64'hBFF0000400000000; - ans = 64'hFFF8007FFFFFFFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2681951\n"); - end - xrf = 64'h380FFFFFEFDFFFFE; - y = 64'h7FE0000000000001; - zrf = 64'h8010000000000001; - ans = 64'h77FFFFFFEFE00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2682565\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h4C40007FFFFFFBFF; - zrf = 64'hFFE00010FFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2683179\n"); - end - xrf = 64'hFFE60948A045D052; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h416830715668BF7E; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2683793\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hB7EFFFFFFFFFFFFF; - zrf = 64'hC340000000000001; - ans = 64'hF7EFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2684407\n"); - end - xrf = 64'h43EBE98FE3471EF1; - y = 64'hC3DFFC00000001FF; - zrf = 64'hFFDFFFFF7FFFFFFF; - ans = 64'hFFDFFFFF7FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2685021\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h7FF0000000000001; - zrf = 64'h7FE0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2685635\n"); - end - xrf = 64'h367FEFFFFFDFFFFF; - y = 64'h3C28000000008000; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2686249\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h3FC0008FFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2686863\n"); - end - xrf = 64'h3FBFFFE000000007; - y = 64'h787FFFE0003FFFFE; - zrf = 64'h43CFFE0000001FFE; - ans = 64'h784FFFC0005FFFC5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2687477\n"); - end - xrf = 64'h3CA000400000007F; - y = 64'h8000000000000000; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h800FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2688091\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h3FE00000007FFEFF; - zrf = 64'h403FFFFE00008000; - ans = 64'h7FE00000007FFEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2688705\n"); - end - xrf = 64'hAB80000008000020; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hC3CFFFFFFFFFC010; - ans = 64'hC3CFFFFFFFFFC010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2689319\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hB801FFFDFFFFFFFF; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hF801FFFDFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2689933\n"); - end - xrf = 64'hC00FFFC003FFFFFF; - y = 64'hFFE003FFFEFFFFFF; - zrf = 64'h3FEE3B6F7416A277; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2690547\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h8010000000000000; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2691161\n"); - end - xrf = 64'hE100000080000006; - y = 64'hC04FFFFFFFFE000F; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h616000007FFF000D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2691775\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h8010000000000001; - zrf = 64'h381FFFF802000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2692389\n"); - end - xrf = 64'h40B0048000000000; - y = 64'h3FE3ED76B6489C1D; - zrf = 64'h3E7FBFFFFFFFFFBF; - ans = 64'h40A3F3117FAFD889; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2693003\n"); - end - xrf = 64'h41DFFFFFFF7FF000; - y = 64'h801FFFFFFFFFFFFE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2693617\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h41C000000000013E; - zrf = 64'hFFF004000003FFFE; - ans = 64'hFFF804000003FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2694231\n"); - end - xrf = 64'hF7D00001F7FFFFFF; - y = 64'hBCA0000000000001; - zrf = 64'h7FD0000000017FFF; - ans = 64'h7FD0000000017FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2694845\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hBA6FFFFFFFFFFFEB; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hFA6FFFFFFFFFFFEA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2695459\n"); - end - xrf = 64'h43F04EE0AE1C051B; - y = 64'hC0700FDFFFFFFFFE; - zrf = 64'hB7F1FFFFFEFFFFFF; - ans = 64'hC4705F0EF108C4E6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2696073\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'hFCAFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2696687\n"); - end - xrf = 64'h3FA00400000007FF; - y = 64'h0014DB112901A6D9; - zrf = 64'h3FD0000000000000; - ans = 64'h3FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2697301\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hBFD0000000000000; - zrf = 64'h41F03FFFFFE00000; - ans = 64'hFFCFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2697915\n"); - end - xrf = 64'hB812000000080000; - y = 64'hC24FFFFFFF00003F; - zrf = 64'hB98FE003FFFFFFFF; - ans = 64'h3A71FFC03F700023; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2698529\n"); - end - xrf = 64'hBCDFFFFFFE1FFFFF; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2699143\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hC03FFFFDFFFDFFFE; - zrf = 64'h3FFFBFFFFFF7FFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2699757\n"); - end - xrf = 64'h3FB000000100007F; - y = 64'hBFE0000000000000; - zrf = 64'hC00008001FFFFFFF; - ans = 64'hC000480020040001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2700371\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hD0126E987899EAFF; - zrf = 64'hC000000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2700985\n"); - end - xrf = 64'hBC8117A78D57DE17; - y = 64'hBFE0000001FFFBFF; - zrf = 64'hC3FA1CA7FD3C5593; - ans = 64'hC3FA1CA7FD3C5593; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2701599\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h4010000000000000; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2702213\n"); - end - xrf = 64'h434DFFFFFFFFFFDE; - y = 64'h71E86FF6019437FA; - zrf = 64'h3CA0000000000001; - ans = 64'h7546E8F6A17AF460; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2702827\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h3C63CCE2F498B2CB; - ans = 64'hFFEFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2703441\n"); - end - xrf = 64'hC74B7FFFFFFFFFFE; - y = 64'hBFF000001000003F; - zrf = 64'hC0E0000002000007; - ans = 64'h474B80001B80006A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2704055\n"); - end - xrf = 64'h83BFFC7FFFFFFFFF; - y = 64'hBFF0000000000001; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2704669\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h3FD8E249A50C7C32; - zrf = 64'h38101FFFFFFFFFC0; - ans = 64'h7FD8E249A50C7C31; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2705283\n"); - end - xrf = 64'hC1E0000400000100; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h408FF77FFFFFFFFF; - ans = 64'h41F000043FEF00FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2705897\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h04B0DDD888155295; - zrf = 64'hBFF0000000000001; - ans = 64'h44B0DDD888155294; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2706511\n"); - end - xrf = 64'hC034B755456A5C7C; - y = 64'h41E0000000000000; - zrf = 64'hBF1FFFFFFF7FFC00; - ans = 64'hC224B755456A5C8C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2707125\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hC000000000000001; - zrf = 64'h4000000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2707739\n"); - end - xrf = 64'h3F4FFFEFFDFFFFFF; - y = 64'hC1F40DF17AEAA200; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'hC1540DE772B10572; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2708353\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h66700003FFDFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2708967\n"); - end - xrf = 64'hBFEFFFFFFFFFC000; - y = 64'h002080000000000F; - zrf = 64'h0B9FFFFC0000007F; - ans = 64'h0B9FFFFC0000007F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2709581\n"); - end - xrf = 64'h40500000007FFDFF; - y = 64'hC010000000000000; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFFFFFFFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2710195\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hC7E1FFFFFFFFFFFC; - zrf = 64'hC7D6500338CDEEFD; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2710809\n"); - end - xrf = 64'hBEDFFF800000003E; - y = 64'hC010000000000001; - zrf = 64'h3FF0000400000007; - ans = 64'h3FF00023FF800007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2711423\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h3FE0001000000007; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'h7FE0001000000006; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2712037\n"); - end - xrf = 64'hBFC000000020000F; - y = 64'hC3488494D9B089E2; - zrf = 64'h400953DDF7890BE9; - ans = 64'h43188494D9E1932F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2712651\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hC340000000000000; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2713265\n"); - end - xrf = 64'h37E0080000020000; - y = 64'h3FC9D48FACB73124; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h37B9E179F490C74F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2713879\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hC340000000000001; - zrf = 64'h3FBFDFFFFFFEFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2714493\n"); - end - xrf = 64'h45C000003FFFFFFF; - y = 64'hC56FFFFF8003FFFF; - zrf = 64'h4DF00000080007FF; - ans = 64'h4DF00000080005FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2715107\n"); - end - xrf = 64'h403FFFC000000FFE; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'hC39FFFC000000FFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2715721\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'h41CFFDFFFFFFFC00; - zrf = 64'hC1DFF80100000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2716335\n"); - end - xrf = 64'h92FCBDCB2FA72585; - y = 64'hFFE0000000000000; - zrf = 64'h3DFFC0000001FFFF; - ans = 64'h52ECBDCB2FA72585; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2716949\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hC3C00400000007FE; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2717563\n"); - end - xrf = 64'hBCA0000000010010; - y = 64'hC3CFC00000000002; - zrf = 64'hB7E0003FFFFFFFDF; - ans = 64'h407FC0000001FC22; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2718177\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2718791\n"); - end - xrf = 64'hC0EFFFDFFFFFFBFF; - y = 64'hBE3FFFFFFF7FFC00; - zrf = 64'h0000000000000000; - ans = 64'h3F3FFFDFFF7FF87F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2719405\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hFFF0000000000000; - zrf = 64'h801FFFFFFFFFFFF4; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2720019\n"); - end - xrf = 64'hC3DFFDFFFFFFFC00; - y = 64'hC7EFFC0000000000; - zrf = 64'h3FD007FFFFFFFFBF; - ans = 64'h4BDFFA003FFFFC01; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2720633\n"); - end - xrf = 64'h7FDFFFFFFFF87FFF; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h4010000000000000; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2721247\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFF; - y = 64'hB7F0007FFFFDFFFF; - zrf = 64'h41D00009FFFFFFFF; - ans = 64'hF7F0007FFFFDFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2721861\n"); - end - xrf = 64'h41F000007FFEFFFF; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h31620000000001FF; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2722475\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hBCAE75B7DA64DA8B; - zrf = 64'hBFD0000000000000; - ans = 64'hFCAE75B7DA64DA89; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2723089\n"); - end - xrf = 64'h400000000004001F; - y = 64'hB23FFFFFC2000000; - zrf = 64'hC0303FFFFFDFFFFF; - ans = 64'hC0303FFFFFDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2723703\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h3FE0000000000000; - ans = 64'h4011FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2724317\n"); - end - xrf = 64'h37FFFFFF7FFFFFDE; - y = 64'h3FE0004400000000; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2724931\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h801AD09F91401F94; - ans = 64'h400FFFFFFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2725545\n"); - end - xrf = 64'h510FE00000000004; - y = 64'h3FC00000010007FF; - zrf = 64'h7FDFBF0000000000; - ans = 64'h7FDFBF0000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2726159\n"); - end - xrf = 64'h480F30C3D189FBF8; - y = 64'h0010000000000001; - zrf = 64'h4000000000000001; - ans = 64'h4000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2726773\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h801FC40000000000; - zrf = 64'h405BFFFFEFFFFFFF; - ans = 64'h405A03BFEFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2727387\n"); - end - xrf = 64'h8F6FFFFFFFFFFF3F; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h3E70403FFFFFFFFF; - ans = 64'h3E70403FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2728001\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hCA60000000003FBF; - zrf = 64'hBCA0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2728615\n"); - end - xrf = 64'hFFD000007FBFFFFF; - y = 64'h409529DF079AEA06; - zrf = 64'hC1F000002000000F; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2729229\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h3CA0000000000001; - zrf = 64'h3FD0000000000001; - ans = 64'h7CA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2729843\n"); - end - xrf = 64'hC1BFFC0000FFFFFE; - y = 64'hC8000001FFC00000; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2730457\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hBFF0007FFFFF7FFF; - ans = 64'h7CAFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2731071\n"); - end - xrf = 64'hC3431371803FAF5C; - y = 64'hC01E02B00FBA67F6; - zrf = 64'hBECE7C5499D55A61; - ans = 64'h4371E3D493A435F1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2731685\n"); - end - xrf = 64'h47E07FFFFFFFFFBE; - y = 64'h3FD0000000000000; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h47C07FFFFFFFFFBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2732299\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hED7FFFFFFFFFE007; - zrf = 64'hDDCE000000800000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2732913\n"); - end - xrf = 64'hAE3FFFFFF7FFFF7F; - y = 64'h3FD0000000000001; - zrf = 64'h3EB0000200007FFF; - ans = 64'h3EB0000200007FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2733527\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h4018AD954FA2661C; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2734141\n"); - end - xrf = 64'hC3F0000001FFFF7E; - y = 64'hBD80008000001FFF; - zrf = 64'hC3CFFFFFC1FFFFFE; - ans = 64'hC3CFFFFFC1FEFFF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2734755\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h3FE0000000000000; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h7FDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2735369\n"); - end - xrf = 64'hC005FFFFFFFFFFFF; - y = 64'h00131D0C934B03B5; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2735983\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h3FE0000000000001; - zrf = 64'hC01000003E000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2736597\n"); - end - xrf = 64'h3410007FFFFFFFF0; - y = 64'h3FDFFFFE07FFFFFF; - zrf = 64'hB7E42BFC32088109; - ans = 64'hB7E42BFC32088109; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2737211\n"); - end - xrf = 64'h40C9F9C3F5F48C89; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h40C9FA43F5F48C87; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2737825\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h56EE000003FFFFFF; - zrf = 64'h480EFFFFFFFF8000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2738439\n"); - end - xrf = 64'h6152307E846B6B2F; - y = 64'h3FF0000000000000; - zrf = 64'h3FBBFFFFFFFFFF7E; - ans = 64'h6152307E846B6B2F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2739053\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h3FCFFFFFF7FFFFFE; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h7FCFFFFFF7FFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2739667\n"); - end - xrf = 64'hC060FFFFFFFFFFFB; - y = 64'hC03BE00000000000; - zrf = 64'hBFC1625D444CD847; - ans = 64'h40AD9DBA768AEEC4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2740281\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2740895\n"); - end - xrf = 64'h3FDFFFFFFC000FFE; - y = 64'h7FEC0FE52F009BCC; - zrf = 64'hC340000000000000; - ans = 64'h7FDC0FE52B7EAD2C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2741509\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h4000000000000000; - zrf = 64'h408FFEFFFFFFFFFB; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2742123\n"); - end - xrf = 64'h4DFFFFFD00000000; - y = 64'hC212000000000000; - zrf = 64'h43D00003FEFFFFFF; - ans = 64'hD021FFFE50000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2742737\n"); - end - xrf = 64'h3E3FFFFFFFFFDFBE; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE0000010000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2743351\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hC801A4C88B03EBDD; - zrf = 64'h402F800020000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2743965\n"); - end - xrf = 64'hB26FFFFC00000003; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h84B00007FFFFFFF7; - ans = 64'hB28FFFFC00000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2744579\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hC00130F25C0FC4FE; - zrf = 64'h8000000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2745193\n"); - end - xrf = 64'h404087982EBE099A; - y = 64'hBFBFFBFFFFFF0000; - zrf = 64'h403004000FFFFFFF; - ans = 64'h4027C53C82242930; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2745807\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h0010000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2746421\n"); - end - xrf = 64'h403249857D09F98B; - y = 64'h402FFFE000000020; - zrf = 64'hC010000000000001; - ans = 64'h4072097333847C93; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2747035\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h001DB6DB217A3447; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2747649\n"); - end - xrf = 64'hB1A0000000000000; - y = 64'h402001FFFFFEFFFE; - zrf = 64'h403FFFFFFC000002; - ans = 64'h403FFFFFFC000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2748263\n"); - end - xrf = 64'h6DD07FFFFFFFFFF6; - y = 64'h4340000000000001; - zrf = 64'h3FD0000000000001; - ans = 64'h71207FFFFFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2748877\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hC00FFFFFEFFEFFFF; - zrf = 64'h3D900000803FFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2749491\n"); - end - xrf = 64'h3F90000000800000; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'hFFFFFFFFFFFFFE01; - ans = 64'hFFFFFFFFFFFFFE01; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2750105\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hBFE0000000002007; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2750719\n"); - end - xrf = 64'h37EFFBFFFFFFC000; - y = 64'h378FFBFFFFFFFF7F; - zrf = 64'h427766C3FF898D65; - ans = 64'h427766C3FF898D65; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2751333\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h7FE0000000000001; - zrf = 64'h0000000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2751947\n"); - end - xrf = 64'h4440008000000000; - y = 64'h038ABB97FC6031CE; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2752561\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h801EDFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2753175\n"); - end - xrf = 64'hBE40203FFFFFFFFF; - y = 64'h3FB0000280000000; - zrf = 64'hBAA4591950B7103C; - ans = 64'hBE0020428509FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2753789\n"); - end - xrf = 64'h7FDFFFFFFFFE001F; - y = 64'h7FF0000000000000; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2754403\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h3C3FFFFFFFFF007E; - zrf = 64'h3F4FFFFE000000FE; - ans = 64'h7C3FFFFFFFFF007C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2755017\n"); - end - xrf = 64'hC02FFFFFFFFC0007; - y = 64'h7FF0000000000001; - zrf = 64'hC3F0000037FFFFFE; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2755631\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hBFBFF80000002000; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEC00FFFFFFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2756245\n"); - end - xrf = 64'h3FEC0FFFFFFFFFFE; - y = 64'h37E0082000000000; - zrf = 64'hC0305FFFFFFFFFFF; - ans = 64'hC0305FFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2756859\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2757473\n"); - end - xrf = 64'h800FF81FFFFFFFFF; - y = 64'hC02FFFEC00000000; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hBFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2758087\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h8000000000000001; - zrf = 64'h44B1D069FC89E1A4; - ans = 64'h44B1D069FC89E1A4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2758701\n"); - end - xrf = 64'hFFF000000005FFFF; - y = 64'hC80FFFFFFFFBDFFF; - zrf = 64'h800FFFFFFEFFDFFF; - ans = 64'hFFF800000005FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2759315\n"); - end - xrf = 64'h475426384B2F52FF; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h877426384B2F52FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2759929\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hC083FFFDFFFFFFFF; - zrf = 64'h41F00000000400FF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2760543\n"); - end - xrf = 64'hBFB000000001EFFF; - y = 64'h8010000000000000; - zrf = 64'hC010000000000010; - ans = 64'hC010000000000010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2761157\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h3FD45C4A28015794; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h7FD45C4A28015793; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2761771\n"); - end - xrf = 64'hC003A9DCAAEBFAEA; - y = 64'h7FD8000000000006; - zrf = 64'hC7F2253D67209A0F; - ans = 64'hFFED7ECB0061F866; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2762385\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2762999\n"); - end - xrf = 64'hE8D00000800FFFFF; - y = 64'h3FE000400000000F; - zrf = 64'hBFF0000000000000; - ans = 64'hE8C000408012004E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2763613\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hBCA0000000000000; - zrf = 64'h000020000001FFFF; - ans = 64'hFC9FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2764227\n"); - end - xrf = 64'h3E430E36893A9156; - y = 64'hB85FFFBFFFE00000; - zrf = 64'h47F000003FFDFFFE; - ans = 64'h47F000003FFDFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2764841\n"); - end - xrf = 64'h41CFFFFFFFFFF008; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h0010000000000000; - ans = 64'hBE8FFFFFFFFFF007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2765455\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h7FDFEFFFFFDFFFFE; - zrf = 64'h3FD00000FFFF7FFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2766069\n"); - end - xrf = 64'hC06822393DB1B5D9; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h34C001000000003E; - ans = 64'h3D2822393DB1B5D7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2766683\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h480FFFFFFFFDFFBF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2767297\n"); - end - xrf = 64'h402FFFF803FFFFFF; - y = 64'hBFD00000020001FE; - zrf = 64'hCDE000007FFFFFF0; - ans = 64'hCDE000007FFFFFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2767911\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hBFD0000000000001; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE8000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2768525\n"); - end - xrf = 64'h381F80000000003F; - y = 64'hBC0C24FFA891303C; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2769139\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'hBA10000000000EFE; - ans = 64'hFFDFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2769753\n"); - end - xrf = 64'h4037FFFFFFFFFFFA; - y = 64'hC31FFF8FFFFFFFFE; - zrf = 64'hC1700007FFFFFC00; - ans = 64'hC367FFAC00200009; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2770367\n"); - end - xrf = 64'h000FFFFFFFF00006; - y = 64'hBFE0000000000001; - zrf = 64'h0000000000000001; - ans = 64'h8007FFFFFFF80002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2770981\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hC1C00FFFFFBFFFFF; - zrf = 64'hBFFFFFFFEFC00000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2771595\n"); - end - xrf = 64'hC03FFFFDFFFFC000; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h51FFFFFFFFC00000; - ans = 64'h51FFFFFFFFC00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2772209\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h41F00003FFFFFFFB; - zrf = 64'h4010000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2772823\n"); - end - xrf = 64'h2DD2641B75C4C4DE; - y = 64'hC340800000000100; - zrf = 64'hC020000000000000; - ans = 64'hC020000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2773437\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hBFF0000000000000; - zrf = 64'hC340000000000001; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2774051\n"); - end - xrf = 64'hBFE79A9AE98115B0; - y = 64'hBE70000100000000; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFDFFFFFD0CAC739; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2774665\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'hC80000000100001F; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2775279\n"); - end - xrf = 64'h47F000000FFFFFEF; - y = 64'h37F0BA5592D6B7C6; - zrf = 64'h3FBFFFFFFF000000; - ans = 64'h3FF2BA55A3810D47; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2775893\n"); - end - xrf = 64'h7FF3FFFFFFFFFFFF; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2776507\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h3420007FFFFFFFFC; - zrf = 64'h4010404000000000; - ans = 64'h7420007FFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2777121\n"); - end - xrf = 64'h41EBFFEFFFFFFFFF; - y = 64'hC000000000000001; - zrf = 64'hC34605A8B553962B; - ans = 64'hC34605A99553162B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2777735\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h41CC4B5F23ACBE96; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2778349\n"); - end - xrf = 64'h8170000103FFFFFE; - y = 64'h3FDFFFFFFF00FFFF; - zrf = 64'h22A5204FB3D18829; - ans = 64'h22A5204FB3D18829; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2778963\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2779577\n"); - end - xrf = 64'hC3DFFF003FFFFFFE; - y = 64'h7FF000000020003E; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'h7FF800000020003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2780191\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hC010000000000001; - zrf = 64'hC1DFFBFFFE000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2780805\n"); - end - xrf = 64'hBFBFFFFEFFFBFFFF; - y = 64'hD40FFFFF000003FF; - zrf = 64'hBFB2000002000000; - ans = 64'h53DFFFFDFFFC0BFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2781419\n"); - end - xrf = 64'hC020000000000100; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2782033\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h380010000003FFFE; - zrf = 64'h43F1FFFFBFFFFFFF; - ans = 64'h780010000003FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2782647\n"); - end - xrf = 64'h466FFFFFF0001FFE; - y = 64'hC340000000000000; - zrf = 64'hC15000000008007F; - ans = 64'hC9BFFFFFF0001FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2783261\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h802FC00200000000; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'hC02BC001FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2783875\n"); - end - xrf = 64'hBFF0000001000000; - y = 64'h5700000080000003; - zrf = 64'h41C00100000000FF; - ans = 64'hD70000008100000B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2784489\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2785103\n"); - end - xrf = 64'h37E3FFFFFFFFFBFF; - y = 64'hBEF3431D1F903239; - zrf = 64'hBCA0000000000000; - ans = 64'hBCA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2785717\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hFFE0000000000000; - zrf = 64'hBB6FFFBFFFDFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2786331\n"); - end - xrf = 64'h43C8874EB3D8AEE2; - y = 64'hA87FFFFFFFFDFFFF; - zrf = 64'hBFF001FFFFFFFFFE; - ans = 64'hBFF001FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2786945\n"); - end - xrf = 64'hC3500003FFEFFFFE; - y = 64'hFFE0000000000001; - zrf = 64'hFFE0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2787559\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hC1EFE007FFFFFFFF; - zrf = 64'hC7F0000008000020; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2788173\n"); - end - xrf = 64'hBE40F691785FA275; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'hB35FFF803FFFFFFF; - ans = 64'h7E40F691785FA274; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2788787\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'h4346719A05C360D1; - zrf = 64'h3FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2789401\n"); - end - xrf = 64'hC7F0991CCB0BBE1F; - y = 64'h400FFF7FFFFEFFFE; - zrf = 64'hFFD4000000020000; - ans = 64'hFFD4000000020000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2790015\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hFFF0000000000001; - zrf = 64'hC000000000000000; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2790629\n"); - end - xrf = 64'h423000000002000F; - y = 64'hBF5DFF2DE9D3F850; - zrf = 64'h8010000000000001; - ans = 64'hC19DFF2DE9D7B852; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2791243\n"); - end - xrf = 64'h7FEFFFFFFFFFFFFE; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'hC2E1C2B66781392C; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2791857\n"); - end - xrf = 64'h308D3F161CAAD5D4; - y = 64'h475FFFFFFFC00FFE; - zrf = 64'h3FEF86854B517225; - ans = 64'h3FEF86854B517225; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2792471\n"); - end - xrf = 64'h47EFFFFFFFFD7FFF; - y = 64'h0000000000000000; - zrf = 64'hC340000000000001; + z = 64'hC340000000000000; ans = 64'hC340000000000001; rn = 1; rz = 0; @@ -213814,19 +57960,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -213842,12 +57988,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2793085\n"); + $fwrite(fp,"2483261\n"); end - xrf = 64'h7FF0000000000000; - y = 64'hBCAFFBFFE0000000; - zrf = 64'hC3FFFFFDFFFFFFF0; - ans = 64'hFFF0000000000000; + x = 64'h802A548D6271A8D4; + y = 64'hBFD0000000000000; + z = 64'h4010005000000000; + ans = 64'h4010005000000000; rn = 1; rz = 0; rm = 0; @@ -213861,19 +58007,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -213889,12 +58035,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2793699\n"); + $fwrite(fp,"2485275\n"); end - xrf = 64'h4010FFFFFF7FFFFF; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'hC7E0000040000100; - ans = 64'hC7E0000040000100; + x = 64'hC0EFFAFFFFFFFFFF; + y = 64'h3F1FFBFFFFFFFDFF; + z = 64'hBFC929330A6F28FB; + ans = 64'hC02060251C29BBA3; rn = 1; rz = 0; rm = 0; @@ -213908,19 +58054,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -213936,575 +58082,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2794313\n"); + $fwrite(fp,"2487289\n"); end - xrf = 64'h7FF0000000000000; - y = 64'h3FCFFFFFFFFFB800; - zrf = 64'h3FE0000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2794927\n"); - end - xrf = 64'h402000000003C000; - y = 64'h2BBFFFFFE0000003; - zrf = 64'hC3D9F0847445CB73; - ans = 64'hC3D9F0847445CB73; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2795541\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h0010000000000000; - zrf = 64'hBFF0000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2796155\n"); - end - xrf = 64'h3F20003EFFFFFFFF; - y = 64'hBFF0000000800020; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'hBF20003F00800217; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2796769\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hB5FFFFFFDFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2797383\n"); - end - xrf = 64'h3FD0000000010007; - y = 64'h3F9FFDFFFFFC0000; - zrf = 64'h043FFFFF00000800; - ans = 64'h3F7FFDFFFFFDFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2797997\n"); - end - xrf = 64'h802C7082F2D15588; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2798611\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'hC1800002FFFFFFFF; - zrf = 64'hC3CFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2799225\n"); - end - xrf = 64'h37F0000000FFFFFF; - y = 64'h3CA0000000000001; - zrf = 64'h3EF4E84F0DAF7946; - ans = 64'h3EF4E84F0DAF7946; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2799839\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'hBFFFFF0000000020; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2800453\n"); - end - xrf = 64'h3FFFFFFFEFFFFFDF; - y = 64'h405F7FFEFFFFFFFF; - zrf = 64'hBFC8313D186FF150; - ans = 64'h406F79F2A0F9E462; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2801067\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2801681\n"); - end - xrf = 64'h417FFFC040000000; - y = 64'h3CA00007FFC00000; - zrf = 64'h7FFFFFFFFFFFFFFE; + x = 64'h434FFFFFFFFFFFFE; + y = 64'hBFE0000000000001; + z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -214519,19 +58101,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -214547,12 +58129,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2802295\n"); + $fwrite(fp,"2489303\n"); end - xrf = 64'h7FF0000000000000; - y = 64'h3FD0000000000001; - zrf = 64'hC34FFDFFFFFFFF7F; - ans = 64'h7FF0000000000000; + x = 64'hBFF007F7FFFFFFFF; + y = 64'hBFF0000000000000; + z = 64'h3ED10000007FFFFE; + ans = 64'h3FF007FC4000001F; rn = 1; rz = 0; rm = 0; @@ -214566,19 +58148,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -214594,12 +58176,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2802909\n"); + $fwrite(fp,"2491317\n"); end - xrf = 64'hF0C0003FFFFFFFFC; - y = 64'hBFC040000FFFFFFE; - zrf = 64'hC018E3FC97500574; - ans = 64'h7090404110003FFA; + x = 64'h401FFFFFFBFFFBFF; + y = 64'h3FBFFFEF80000000; + z = 64'hC00000400000007F; + ans = 64'hBFF00088420001F6; rn = 1; rz = 0; rm = 0; @@ -214613,19 +58195,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -214641,12 +58223,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2803523\n"); + $fwrite(fp,"2493331\n"); end - xrf = 64'hFF0FB3A76863C927; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hFEFFB3A76863C926; + x = 64'h434FFFFFFFFFFFFE; + y = 64'hC000000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hC360000000000000; rn = 1; rz = 0; rm = 0; @@ -214660,19 +58242,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -214688,11 +58270,246 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2804137\n"); + $fwrite(fp,"2495345\n"); end - xrf = 64'h7FF0000000000000; - y = 64'hC3E00087FFFFFFFE; - zrf = 64'h480FFFFFFFDFFFF6; + x = 64'hBF3FFFFFDC000000; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hBEF00000000043FE; + ans = 64'h3F5FBFFFDBFFFEEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2497359\n"); + end + x = 64'h0F2FDFEFFFFFFFFF; + y = 64'h3A7FFFFFFDFF7FFF; + z = 64'hC09C6DB48153D631; + ans = 64'hC09C6DB48153D631; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2499373\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'hC340000000000000; + z = 64'hBFF0000000000001; + ans = 64'hC69FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2501387\n"); + end + x = 64'h47E0000037FFFFFE; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'hBFFEFFFFFFBFFFFE; + ans = 64'hCB40000037FFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2503401\n"); + end + x = 64'h41D47345FAF3A236; + y = 64'hBCA000EFFFFFFFFE; + z = 64'h401E32064EC9BA5F; + ans = 64'h401E3206448F7E01; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2505415\n"); + end + x = 64'h434FFFFFFFFFFFFE; + y = 64'hFFF0000000000000; + z = 64'h4340000000000000; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -214707,19 +58524,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -214735,12 +58552,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2804751\n"); + $fwrite(fp,"2507429\n"); end - xrf = 64'hC80000007F7FFFFF; - y = 64'h3FE0000000000000; - zrf = 64'hB64007FFFFFEFFFF; - ans = 64'hC7F000007F7FFFFF; + x = 64'hBFFFC000000FFFFF; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h7FE400000003FFFF; + ans = 64'hFFFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -214754,19 +58571,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -214782,12 +58599,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2805365\n"); + $fwrite(fp,"2509443\n"); end - xrf = 64'h7FF0000000000000; - y = 64'hC8007FFFFFFFDFFF; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; + x = 64'hBD2D87ECBE7232FC; + y = 64'h46FFFFD7FFFFFFFF; + z = 64'h3C8FC000FFFFFFFF; + ans = 64'hC43D87C7D48A44EC; rn = 1; rz = 0; rm = 0; @@ -214801,19 +58618,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -214829,1656 +58646,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2805979\n"); + $fwrite(fp,"2511457\n"); end - xrf = 64'h402FFF807FFFFFFF; - y = 64'h37FC8B335383047F; - zrf = 64'h4340200000080000; - ans = 64'h4340200000080000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2806593\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2807207\n"); - end - xrf = 64'hC3C0000088000000; - y = 64'hC34A8A318C8B3E44; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2807821\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h3FF0000000000000; - zrf = 64'h7FEDFFFFFFBFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2808435\n"); - end - xrf = 64'hFFFFFE0000000004; - y = 64'h4270000000010FFF; - zrf = 64'hB84FFFFF7FF7FFFF; - ans = 64'hFFFFFE0000000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2809049\n"); - end - xrf = 64'h43A03FFFFFFEFFFF; - y = 64'h3FF0000000000001; - zrf = 64'hC000000000000000; - ans = 64'h43A03FFFFFFF0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2809663\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'hBFAFFFFFFE1FFFFF; - zrf = 64'hB7FFFFFC08000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2810277\n"); - end - xrf = 64'h47F0000000FFFDFF; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hC1DFFFFFFFFFFEF6; - ans = 64'h4800000000FFFDFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2810891\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h3EAF800000008000; - zrf = 64'h3CA0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2811505\n"); - end - xrf = 64'h5BEFFFFFFFFFEFFE; - y = 64'h7FFFFFFC007FFFFF; - zrf = 64'hC1EFFFFFFEDFFFFF; - ans = 64'h7FFFFFFC007FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2812119\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h4000000000000001; - zrf = 64'hBFD0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2812733\n"); - end - xrf = 64'hBFF80F7B17E98453; - y = 64'hC3D6E30A5A94BC09; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2813347\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hBC5E24D175FF8E44; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2813961\n"); - end - xrf = 64'h4803CCEB031B60A4; - y = 64'h796A522F02E82FC6; - zrf = 64'h480C776C5FE298B2; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2814575\n"); - end - xrf = 64'h403FFDFFFBFFFFFE; - y = 64'h4010000000000000; - zrf = 64'hBFF0000000000001; - ans = 64'h405FBDFFFBFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2815189\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h401FE00000002000; - zrf = 64'h47E000001FFBFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2815803\n"); - end - xrf = 64'h0FC0000003FFF7FF; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h3F407BFFFFFFFFFE; - ans = 64'h3F407BFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2816417\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h3F2000000000043E; - zrf = 64'h0010000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2817031\n"); - end - xrf = 64'hBFD000002000FFFE; - y = 64'hC8044401C84131E5; - zrf = 64'hBFDFFD7FFFFFFFFF; - ans = 64'h47E44401F0CA79B3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2817645\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h4340000000000000; - zrf = 64'hBCA0000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2818259\n"); - end - xrf = 64'hC1F9782AAEE2F6E6; - y = 64'h41F9D1C5D52EC00A; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'hC4048AD7A4DB6198; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2818873\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h41CFFFFEFFFDFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2819487\n"); - end - xrf = 64'hC18403FFFFFFFFFF; - y = 64'h480FFFFFFFFFFFB7; - zrf = 64'hBFE00000000FFFEE; - ans = 64'hC9A403FFFFFFFFD1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2820101\n"); - end - xrf = 64'h800FFFFFFEF7FFFE; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2820715\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h40DFE00000400000; - zrf = 64'hC00122D1E9DB54BA; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2821329\n"); - end - xrf = 64'h533000000003FFF7; - y = 64'h7FE0000000000001; - zrf = 64'hC1E075D8BA1D5302; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2821943\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h41F0000FFFFF7FFF; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2822557\n"); - end - xrf = 64'h4000000001DFFFFF; - y = 64'h473FFFFFFFFF2000; - zrf = 64'h58CFFFEFFFEFFFFF; - ans = 64'h58CFFFEFFFEFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2823171\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2823785\n"); - end - xrf = 64'hBCA308379D8DFF8B; - y = 64'h41EFFFFFFFFFDEFE; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h401FFFFFD9EF90C3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2824399\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h7FF0000000000001; - zrf = 64'hBFAB85887638758B; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2825013\n"); - end - xrf = 64'h3F90000FFFFF8000; - y = 64'h3FB000FFFFEFFFFF; - zrf = 64'h412FEFFFFFFE0000; - ans = 64'h412FF000007E0880; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2825627\n"); - end - xrf = 64'hB0BEFFFFFFF7FFFF; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2826241\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h3FD0003FFFFFC000; - zrf = 64'h43DFFFE000000006; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2826855\n"); - end - xrf = 64'hB7FFFFDFFFFFF7FF; - y = 64'h8000000000000000; - zrf = 64'h3FBFFFFFFDFFDFFF; - ans = 64'h3FBFFFFFFDFFDFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2827469\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'hBF6020000003FFFE; - zrf = 64'hFFFFFFFFFFFFFFFE; + x = 64'h7FE0000000000000; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -216493,19 +58665,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -216521,12 +58693,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2828083\n"); + $fwrite(fp,"2513471\n"); end - xrf = 64'h411FFFFFFFFDFEFE; - y = 64'hB806E5E85D3FD5BC; - zrf = 64'hC02FFFFFFFFF7FFD; - ans = 64'hC02FFFFFFFFF7FFD; + x = 64'hC6EA598C18FEC705; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hC4F8080000000000; + ans = 64'hC4F8080000000000; rn = 1; rz = 0; rm = 0; @@ -216540,19 +58712,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -216568,12 +58740,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2828697\n"); + $fwrite(fp,"2515485\n"); end - xrf = 64'h7FF0000000000000; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; + x = 64'hBFFBEA8B82A394CD; + y = 64'h43D3EF2684B3792F; + z = 64'h3FEFFFFF0001FFFF; + ans = 64'hC3E163E431D2926A; rn = 1; rz = 0; rm = 0; @@ -216587,19 +58759,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -216615,12 +58787,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2829311\n"); + $fwrite(fp,"2517499\n"); end - xrf = 64'h43CFFF7FDFFFFFFE; - y = 64'h41FFFEFFEFFFFFFF; - zrf = 64'h4010000000000000; - ans = 64'h45DFFE7FD401400D; + x = 64'h7FE0000000000000; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h7C9FFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -216634,19 +58806,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -216662,12 +58834,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2829925\n"); + $fwrite(fp,"2519513\n"); end - xrf = 64'h7FF0000000000000; - y = 64'h8010000000000000; - zrf = 64'h46C5C698A716C584; - ans = 64'hFFF0000000000000; + x = 64'h445FF7FFEFFFFFFF; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h41EFEFFFFFFFFFF6; + ans = 64'h444FF7FFF0007FBE; rn = 1; rz = 0; rm = 0; @@ -216681,19 +58853,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -216709,12 +58881,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2830539\n"); + $fwrite(fp,"2521527\n"); end - xrf = 64'hAF408000FFFFFFFE; - y = 64'hBFE00000100007FF; - zrf = 64'hBFF000001FFFFFFB; - ans = 64'hBFF000001FFFFFFB; + x = 64'hBD5EC6885C477DBA; + y = 64'hB81FFFFC00000008; + z = 64'hBE5EAB9C5EE587B9; + ans = 64'hBE5EAB9C5EE587B9; rn = 1; rz = 0; rm = 0; @@ -216728,19 +58900,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -216756,12 +58928,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2831153\n"); + $fwrite(fp,"2523541\n"); end - xrf = 64'h3F5000000000FEFF; - y = 64'h8010000000000001; - zrf = 64'hBFD0000000000000; - ans = 64'hBFD0000000000000; + x = 64'h7FE0000000000000; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h7FDFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -216775,19 +58947,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -216803,12 +58975,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2831767\n"); + $fwrite(fp,"2525555\n"); end - xrf = 64'h7FF0000000000000; - y = 64'hC3FFFFFFFF801000; - zrf = 64'h000FFFFFFFDFFC00; - ans = 64'hFFF0000000000000; + x = 64'hC01010001FFFFFFF; + y = 64'h3FF0000000000001; + z = 64'h43FFFFFFFFE1FFFE; + ans = 64'h43FFFFFFFFE1FFFE; rn = 1; rz = 0; rm = 0; @@ -216822,19 +58994,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -216850,12 +59022,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2832381\n"); + $fwrite(fp,"2527569\n"); end - xrf = 64'hC35FFF000000003F; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h79300001001FFFFE; - ans = 64'h79300001001FFFFE; + x = 64'h4180000000000406; + y = 64'h9630FE0000000000; + z = 64'hC01FFFFFF0000007; + ans = 64'hC01FFFFFF0000007; rn = 1; rz = 0; rm = 0; @@ -216869,19 +59041,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -216897,340 +59069,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2832995\n"); + $fwrite(fp,"2529583\n"); end - xrf = 64'h7FF0000000000000; - y = 64'hBFF003FE00000000; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2833609\n"); - end - xrf = 64'h00200000003FFFBE; - y = 64'h41FFFFFFE0000400; - zrf = 64'h3FC0040000200000; - ans = 64'h3FC0040000200000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2834223\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'hBCA0000000000001; - zrf = 64'h8000000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2834837\n"); - end - xrf = 64'hC340003FFFFFFFFF; - y = 64'hC570000004FFFFFF; - zrf = 64'h4000000000000001; - ans = 64'h48C00040050013FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2835451\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h801400000000FFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2836065\n"); - end - xrf = 64'h4584000000000080; - y = 64'h4017FFFFEFFFFFFF; - zrf = 64'h47FE1280A05363FA; - ans = 64'h47FE1280A05453FA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2836679\n"); - end - xrf = 64'h00200010000FFFFE; - y = 64'hBFD0000000000000; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2837293\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h41C73BE56BB37EBE; - zrf = 64'hC1DFFFFFFFE7FFFF; + x = 64'h7FE0000000000000; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hC340000000000000; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -217245,19 +59088,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -217273,12 +59116,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2837907\n"); + $fwrite(fp,"2531597\n"); end - xrf = 64'hFFFBF1F5EF2E2892; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hC020000102000000; - ans = 64'hFFFBF1F5EF2E2892; + x = 64'hBD7EC05DFC32DDF5; + y = 64'h4010000000000001; + z = 64'hC3E01FEFFFFFFFFE; + ans = 64'hC3E01FEFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -217292,19 +59135,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -217320,12 +59163,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2838521\n"); + $fwrite(fp,"2533611\n"); end - xrf = 64'h7FF0000000000000; - y = 64'h801FAAF2E4C19308; - zrf = 64'hFFE0000000000001; - ans = 64'hFFF0000000000000; + x = 64'hC0C201D33203D333; + y = 64'hC3DFF00000007FFF; + z = 64'h381000001F7FFFFF; + ans = 64'h44B1F8D2486B1950; rn = 1; rz = 0; rm = 0; @@ -217339,19 +59182,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -217367,12 +59210,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2839135\n"); + $fwrite(fp,"2535625\n"); end - xrf = 64'hC1D000000003FFFF; - y = 64'h3C4807B2AD0CFCE1; - zrf = 64'hBFEBD757A7E46DCA; - ans = 64'hBFEBD757A964E8F5; + x = 64'h7FE0000000000000; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -217386,19 +59229,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -217414,12 +59257,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2839749\n"); + $fwrite(fp,"2537639\n"); end - xrf = 64'h7FF0000000000000; - y = 64'hBFE0000000000000; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; + x = 64'h40512DA7BCF2D356; + y = 64'h7FE0000000000001; + z = 64'hBFFFFFBFFFFFFFBF; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -217433,19 +59276,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -217461,12 +59304,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2840363\n"); + $fwrite(fp,"2539653\n"); end - xrf = 64'h8A400000007E0000; - y = 64'h400FF8000000FFFE; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFF; + x = 64'hC1EFFFFFFFFF1FFE; + y = 64'h400EFFFFFDFFFFFF; + z = 64'h56D000FDFFFFFFFF; + ans = 64'h56D000FDFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -217480,19 +59323,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -217508,12 +59351,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2840977\n"); + $fwrite(fp,"2541667\n"); end - xrf = 64'h7FF0000000000000; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h40DBFFFFFFFFF7FE; - ans = 64'hFFF0000000000000; + x = 64'h7FE0000000000000; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -217527,19 +59370,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -217555,12 +59398,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2841591\n"); + $fwrite(fp,"2543681\n"); end - xrf = 64'h47FB58DEE3FCB3A6; - y = 64'hC7E000000003FDFE; - zrf = 64'h4000000000000022; - ans = 64'hCFEB58DEE403866F; + x = 64'hF4F000000000F800; + y = 64'h8000000000000000; + z = 64'h40C0043FFFFFFFFF; + ans = 64'h40C0043FFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -217574,19 +59417,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -217602,12 +59445,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2842205\n"); + $fwrite(fp,"2545695\n"); end - xrf = 64'hC01FFF0000000001; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h401FFEFFFFFFFFFF; + x = 64'hC1B00800FFFFFFFF; + y = 64'hC076927C86FDAFBF; + z = 64'hBF80001EFFFFFFFF; + ans = 64'h42369DC72E68F505; rn = 1; rz = 0; rm = 0; @@ -217621,19 +59464,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -217649,12 +59492,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2842819\n"); + $fwrite(fp,"2547709\n"); end - xrf = 64'h7FF0000000000000; - y = 64'hB7E24093523AA87A; - zrf = 64'hC030000040020000; - ans = 64'hFFF0000000000000; + x = 64'h7FE0000000000000; + y = 64'h8010000000000001; + z = 64'hBFF0000000000001; + ans = 64'hC008000000000002; rn = 1; rz = 0; rm = 0; @@ -217668,19 +59511,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -217696,12 +59539,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2843433\n"); + $fwrite(fp,"2549723\n"); end - xrf = 64'h40354998F7F1DCE5; - y = 64'hBFF0000000000001; - zrf = 64'hCC1083FFFFFFFFFE; - ans = 64'hCC1083FFFFFFFFFE; + x = 64'h400FFFFDF0000000; + y = 64'hBCA0000000000000; + z = 64'hC20CBD47BB1ACD33; + ans = 64'hC20CBD47BB1ACD33; rn = 1; rz = 0; rm = 0; @@ -217715,19 +59558,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -217743,12 +59586,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2844047\n"); + $fwrite(fp,"2551737\n"); end - xrf = 64'h7FF0000000000000; - y = 64'hC24132F19425406D; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; + x = 64'h43410000007FFFFF; + y = 64'hBEE462F95CA516E0; + z = 64'h2EDFFFFFFDFFFBFE; + ans = 64'hC235A928F3128018; rn = 1; rz = 0; rm = 0; @@ -217762,19 +59605,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -217790,12 +59633,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2844661\n"); + $fwrite(fp,"2553751\n"); end - xrf = 64'h3F8FF7FFFFFF7FFE; - y = 64'h3FD84FD0BC13D2AD; - zrf = 64'h37FD165AFFD1797D; - ans = 64'h3F7849BCC7E46C78; + x = 64'h7FE0000000000000; + y = 64'hBFD0000000000001; + z = 64'h4340000000000000; + ans = 64'hFFC0000000000001; rn = 1; rz = 0; rm = 0; @@ -217809,19 +59652,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -217837,11 +59680,246 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2845275\n"); + $fwrite(fp,"2555765\n"); end - xrf = 64'h7FF0000000000000; + x = 64'h5BB38757B6D1035E; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hC7FFFFDFF0000000; + ans = 64'hDBA38757B6D1035D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2557779\n"); + end + x = 64'h3FA000083FFFFFFF; + y = 64'hC0236A374BC6D622; + z = 64'h7FFD20EAEDAEB318; + ans = 64'h7FFD20EAEDAEB318; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2559793\n"); + end + x = 64'h7FE0000000000000; + y = 64'hBFF0000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2561807\n"); + end + x = 64'hBFD0008FFFFFFFFF; y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h7FEFFFFFFFFFFFFF; + z = 64'hC7F0003FFFFFFFBF; + ans = 64'hC7F0003FFFFFFFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2563821\n"); + end + x = 64'hBFB5C3596BC996A8; + y = 64'h2418829CEEE07D74; + z = 64'h2F18000000001FFF; + ans = 64'h2F18000000001FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2565835\n"); + end + x = 64'h7FE0000000000000; + y = 64'hC010000000000000; + z = 64'hBCAFFFFFFFFFFFFF; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -217856,19 +59934,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -217884,12 +59962,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2845889\n"); + $fwrite(fp,"2567849\n"); end - xrf = 64'h40515FAC435403A8; - y = 64'h48FAAF3AB115872C; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h495CF9BE14A322EB; + x = 64'h47FEB3CE3683C2DE; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h403FFFFFDFFEFFFF; + ans = 64'hC82EB3CE3683C2DC; rn = 1; rz = 0; rm = 0; @@ -217903,19 +59981,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -217931,11 +60009,58 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2846503\n"); + $fwrite(fp,"2569863\n"); end - xrf = 64'h7FF0000000000000; - y = 64'hC000000000000000; - zrf = 64'h000FFFE000000000; + x = 64'h4044AD4CBA8C54EB; + y = 64'h939FFFDFFFEFFFFF; + z = 64'hC0AFFF000003FFFF; + ans = 64'hC0AFFF000003FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2571877\n"); + end + x = 64'h7FE0000000000000; + y = 64'hFFE0000000000000; + z = 64'h3FF0000000000001; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -217950,19 +60075,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -217978,11 +60103,1327 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2847117\n"); + $fwrite(fp,"2573891\n"); end - xrf = 64'hC270000007FFFFC0; + x = 64'h40300007FFFF0000; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h7713FFFFFFFFFFEE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2575905\n"); + end + x = 64'h002A8A671164C4C0; + y = 64'hBFD000FFFDFFFFFF; + z = 64'h41701000000000FF; + ans = 64'h41701000000000FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2577919\n"); + end + x = 64'h7FE0000000000000; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2579933\n"); + end + x = 64'h91FFA5AB434ED1A6; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hC02FFFDFFFF7FFFF; + ans = 64'hC02FFFDFFFF7FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2581947\n"); + end + x = 64'h40F89870592100EB; + y = 64'h380FFFFE00000040; + z = 64'h3FFFF8003FFFFFFE; + ans = 64'h3FFFF8003FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2583961\n"); + end + x = 64'h7FE0000000000001; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + 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,"2585975\n"); + end + x = 64'hBD7000400000003F; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hC3DFFFFE03FFFFFE; + ans = 64'hC3DFFFFE03FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2587989\n"); + end + x = 64'hC0000001000003FE; + y = 64'hFFEF7FBFFFFFFFFF; + z = 64'hC08637FF3FC3CF17; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2590003\n"); + end + x = 64'h7FE0000000000001; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h7FD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2592017\n"); + end + x = 64'h3FB00000000FFFFE; + y = 64'h3FE0000000000001; + z = 64'h413001FFDFFFFFFF; + ans = 64'h413001FFE7FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2594031\n"); + end + x = 64'h001FFFFF003FFFFE; + y = 64'hC02FFFFE7FFFFFFF; + z = 64'hC0232C4C60814675; + ans = 64'hC0232C4C60814675; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2596045\n"); + end + x = 64'h7FE0000000000001; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2598059\n"); + end + x = 64'hFFF00FFDB3690C59; + y = 64'h4000000000000001; + z = 64'h3BC3D6DDE1AFB256; + ans = 64'hFFF80FFDB3690C59; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2600073\n"); + end + x = 64'hB8E000FFFFFFFFFC; + y = 64'hBE100000007FFBFF; + z = 64'h3CA000010001FFFF; + ans = 64'h3CA000010001FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2602087\n"); + end + x = 64'h7FE0000000000001; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2604101\n"); + end + x = 64'hC08FFFFFFFE000FF; + y = 64'h4340000000000000; + z = 64'hBB70000000400080; + ans = 64'hC3DFFFFFFFE000FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2606115\n"); + end + x = 64'h5F5FFEFFFFFFFF7F; + y = 64'h4020200002000000; + z = 64'hC1CF42BE33A182EE; + ans = 64'h5F901F7F01FFEFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2608129\n"); + end + x = 64'h7FE0000000000001; + y = 64'h7FE0000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2610143\n"); + end + x = 64'h52225CBAA881CC61; + y = 64'h7FF0000000000000; + z = 64'hBFB0000000001003; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2612157\n"); + end + x = 64'h39BFFFFFFFEFFFBF; + y = 64'hBFC007FFF7FFFFFF; + z = 64'hB49000000000000A; + ans = 64'hB99007FFF7F7FBDE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2614171\n"); + end + x = 64'h7FE0000000000001; + y = 64'h8000000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCC8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2616185\n"); + end + x = 64'hCC5FFC01FFFFFFFF; + y = 64'h8010000000000000; + z = 64'hC06E05881E1A05C1; + ans = 64'hC06E05881E1A05C1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2618199\n"); + end + x = 64'hBF800001000001FF; + y = 64'hFFF00000001FFF7E; + z = 64'hC1DFFFFFFFF807FE; + ans = 64'hFFF80000001FFF7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2620213\n"); + end + x = 64'h7FE0000000000001; + y = 64'hBCA0000000000001; + z = 64'h3FF0000000000001; + ans = 64'hFC90000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2622227\n"); + end + x = 64'h3A7B7160CB764D1B; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h407000004000FFFF; + ans = 64'h407000004000FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2624241\n"); + end + x = 64'hC03000000000FF00; + y = 64'hBFBFFFFEFFFC0000; + z = 64'h36C0008007FFFFFF; + ans = 64'h3FFFFFFEFFFDFE00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2626255\n"); + end + x = 64'h7FE0000000000001; + y = 64'hBFE0000000000000; + z = 64'hC340000000000000; + ans = 64'hFFD0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2628269\n"); + end + x = 64'h1C100000FFFFFFFD; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h50681FB9473AA1DB; + ans = 64'h50681FB9473AA1DB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2630283\n"); + end + x = 64'h3FFFFFFFFFFFBFEF; y = 64'hFFFFFFFFFEFFFFFF; - zrf = 64'hC0102A7E0F9CEE45; + z = 64'h3FCFFC000000007E; ans = 64'hFFFFFFFFFEFFFFFF; rn = 1; rz = 0; @@ -217997,19 +61438,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -218025,10587 +61466,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2847731\n"); + $fwrite(fp,"2632297\n"); end - xrf = 64'hB441FFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h3461FFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2848345\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'hCF52AA0F637D5364; - zrf = 64'hB8000003FFFEFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2848959\n"); - end - xrf = 64'h401FDFFFFFFFFFFC; - y = 64'hC010000000000000; - zrf = 64'hC3DCDE60E50FBCE9; - ans = 64'hC3DCDE60E50FBCE9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2849573\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h3FDC2F8EE87082D3; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2850187\n"); - end - xrf = 64'h402000002000003F; - y = 64'hA8D00FFFFFFFDFFF; - zrf = 64'h468000FFFFFFEFFE; - ans = 64'h468000FFFFFFEFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2850801\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2851415\n"); - end - xrf = 64'hBFCC09699F03D2D5; - y = 64'h7FD9D6B397AD3382; - zrf = 64'h3FE0000000000000; - ans = 64'hFFB6A376D01D6230; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2852029\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h405001FFDFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2852643\n"); - end - xrf = 64'h4043FFFFFFFFFFFF; - y = 64'h38002D4FB3860015; - zrf = 64'h3FB0020000000200; - ans = 64'h3FB0020000000200; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2853257\n"); - end - xrf = 64'hB33FFFFFE0000000; - y = 64'hC340000000000001; - zrf = 64'h8000000000000000; - ans = 64'h368FFFFFE0000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2853871\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'hC00FFFFFFFF07FFE; - zrf = 64'h47DFFDFFFFDFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2854485\n"); - end - xrf = 64'h403FFFFFC000001E; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h41308D4A571E0907; - ans = 64'hC39FFFFFBFFFBDE7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2855099\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h400D3244B30A626D; - zrf = 64'hC010000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2855713\n"); - end - xrf = 64'hC3DFFFFF001FFFFF; - y = 64'hBF80000002200000; - zrf = 64'hBCAE00007FFFFFFF; - ans = 64'h436FFFFF045FFFDD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2856327\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'hFFE0000000000001; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2856941\n"); - end - xrf = 64'h407000001FFFF7FF; - y = 64'hC0178722E8E2710F; - zrf = 64'h3FD0000000000001; - ans = 64'hC097862317F0AB1C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2857555\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h3FB90979A89594A7; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2858169\n"); - end - xrf = 64'hBE2000000010001F; - y = 64'h3F0000FFFF800000; - zrf = 64'h402FFFC0000FFFFF; - ans = 64'h402FFFC0000FFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2858783\n"); - end - xrf = 64'h3F14E7AD5BFBD3E7; - y = 64'hFFF0000000000000; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2859397\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'h316FFFFFFDFFF7FE; - zrf = 64'h7FF000000FFFFFF6; - ans = 64'h7FF800000FFFFFF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2860011\n"); - end - xrf = 64'h3CAFFFFFFFFF0040; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h8000003DFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2860625\n"); - end - xrf = 64'h7FF0000000000000; - y = 64'hC1F8DA003FDA2EDA; - zrf = 64'hC000000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2861239\n"); - end - xrf = 64'hC03000000FFFFFBE; - y = 64'h43F0000000040FFF; - zrf = 64'h47B0000400100000; - ans = 64'h47B0000400100000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2861853\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h0000000000000000; - zrf = 64'h4010000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2862467\n"); - end - xrf = 64'h36CFBFFFFFFFFFF6; - y = 64'h801FE000000000FE; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2863081\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h0000000000000001; - zrf = 64'h4010100000000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2863695\n"); - end - xrf = 64'hFFF97B52C843D305; - y = 64'h001A888ACADE5D0B; - zrf = 64'hD8A00080007FFFFF; - ans = 64'hFFF97B52C843D305; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2864309\n"); - end - xrf = 64'hBFFFFFE000001FFF; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2864923\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h3E34C388504B59C2; - zrf = 64'hA8E00800000003FF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2865537\n"); - end - xrf = 64'h469114017D84F70F; - y = 64'h0010000000000000; - zrf = 64'hBFC00000001FFEFE; - ans = 64'hBFC00000001FFEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2866151\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h43FFFFC3FFFFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2866765\n"); - end - xrf = 64'hBE79FFFFFFFFFFFE; - y = 64'h434AD55EDC5984FD; - zrf = 64'h0023FFFFFFFF7FFE; - ans = 64'hC1D5CD5D1308BC0C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2867379\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2867993\n"); - end - xrf = 64'h31BF7FFFFFFEFFFF; - y = 64'h41F62EE647FE43C3; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h33C5D62AAEDD993C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2868607\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h3CA0000000000000; - zrf = 64'hBFB01FAF3AFF1ABA; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2869221\n"); - end - xrf = 64'h3D0000000800FFFF; - y = 64'h41CEFFFFFFBFFFFE; - zrf = 64'h41D8297E5EAC04D3; - ans = 64'h41D8297E5EAC04F2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2869835\n"); - end - xrf = 64'h480C000000000002; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h44CC000020000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2870449\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'hBF8E1FE03410C3CD; - zrf = 64'hC34001FFFFFFFFFB; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2871063\n"); - end - xrf = 64'h5240000000000FFD; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h3FF00FFFFFFFFFDF; - ans = 64'h4F00000000000FFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2871677\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'hFFEFFFBFFFFC0000; - zrf = 64'hBFEFFFFFFFFFFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2872291\n"); - end - xrf = 64'hF8A0000002001FFF; - y = 64'h43DFFFFF00000002; - zrf = 64'hC34FFFFE00001FFF; - ans = 64'hFC8FFFFF04003FE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2872905\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2873519\n"); - end - xrf = 64'hBFF00000800003FF; - y = 64'h60F0400000080000; - zrf = 64'h0010000000000000; - ans = 64'hE0F040008208040F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2874133\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h41DFFFFFEEFFFFFF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2874747\n"); - end - xrf = 64'h3CA27F59AF996B9F; - y = 64'h4D6FFFFFFFFF7FFE; - zrf = 64'h1F9FFFFFFFDEFFFF; - ans = 64'h4A227F59AF9921A0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2875361\n"); - end - xrf = 64'hBF9FFFFFFFE00002; - y = 64'h3FE0000000000001; - zrf = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2875975\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'hC1FFFFFC0007FFFE; - zrf = 64'hBFEFFEFFFFFFFFBF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2876589\n"); - end - xrf = 64'h3F7FBFFFFFE00000; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h3817BF5A3F991426; - ans = 64'h3F7FBFFFFFDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2877203\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h4FF2AD354C273C4F; - zrf = 64'hBFE0000000000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2877817\n"); - end - xrf = 64'h45AFFFFFFFDEFFFF; - y = 64'hBC3DFFFFFFFFFFEF; - zrf = 64'h800FF7FFFFFFFFFB; - ans = 64'hC1FDFFFFFFE10FEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2878431\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h3FF0000000000001; - zrf = 64'h3FF0000000000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2879045\n"); - end - xrf = 64'hBFD000000100000F; - y = 64'hC09A69FA93AE1A05; - zrf = 64'h0000000000000001; - ans = 64'h407A69FA9554B9C7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2879659\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hC7E10C2C8E90FC29; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2880273\n"); - end - xrf = 64'h646FFFFFFFEFFF7F; - y = 64'hC203FEEF05195503; - zrf = 64'hC010000FFFFFFFDE; - ans = 64'hE683FEEF050F553B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2880887\n"); - end - xrf = 64'h42E8000000080000; - y = 64'h4000000000000000; - zrf = 64'h4010000000000001; - ans = 64'h42F8000000080040; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2881501\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h800138DCFF1B5E8A; - zrf = 64'hFFEFFFFFDFFFDFFF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2882115\n"); - end - xrf = 64'hC1DFFFFFFFFFFFFF; - y = 64'h4000000000000001; - zrf = 64'h41FF000000001FFF; - ans = 64'h41EE000000003FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2882729\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hBFD0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2883343\n"); - end - xrf = 64'h3FFC50269594D1EA; - y = 64'h80100000000FFFBF; - zrf = 64'hC3C5A4DEA80A7E9C; - ans = 64'hC3C5A4DEA80A7E9C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2883957\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h4010000000000000; - zrf = 64'h3FE0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2884571\n"); - end - xrf = 64'h9210003FFFFFFFEF; - y = 64'hBFCFFFFFFFFFFFCF; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2885185\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h4010000000000001; - zrf = 64'h380FFFFFFC00001F; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2885799\n"); - end - xrf = 64'h3FE000000002FFFE; - y = 64'hBF6040FFFFFFFFFF; - zrf = 64'hBFEFFF0001FFFFFF; - ans = 64'hBFF00390410000C3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2886413\n"); - end - xrf = 64'h3F1FFFFFFF7FBFFF; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h401000FFFFFFFBFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2887027\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'hAD0FFFBFFFFFFFFF; - zrf = 64'hC1C30CFDF166F3A9; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2887641\n"); - end - xrf = 64'hBFC88F53F742F741; - y = 64'h4340000000000000; - zrf = 64'hBCADA4273450D0D3; - ans = 64'hC3188F53F742F741; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2888255\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h4020000000FFDFFF; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2888869\n"); - end - xrf = 64'h3FF00040000000FF; - y = 64'h41DFFFFFFFFFFE02; - zrf = 64'hAB00000000012000; - ans = 64'h41E0004000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2889483\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2890097\n"); - end - xrf = 64'hC7E003FFFDFFFFFF; - y = 64'hB97BF69F52A53CD4; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2890711\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h7FE0000000000000; - zrf = 64'hC010000000006FFF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2891325\n"); - end - xrf = 64'h420FFFFFFFE07FFF; - y = 64'h002FFF7FFFFFFFFB; - zrf = 64'hC01FFF3FFFFFFFFF; - ans = 64'hC01FFF3FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2891939\n"); - end - xrf = 64'h43BAE28442A43690; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2892553\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h47E90072420C8EAB; - zrf = 64'hC3C2000001000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2893167\n"); - end - xrf = 64'hBFE0000003FFFFDF; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hB0E0801FFFFFFFFF; - ans = 64'hFFE0000003FFFFDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2893781\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'hFFDFFFFFFFEFFFF7; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2894395\n"); - end - xrf = 64'hBFCF7FFFFFFF0000; - y = 64'hC01AB4C668B81BFF; - zrf = 64'hCCC7FFFFFFFFFBFE; - ans = 64'hCCC7FFFFFFFFFBFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2895009\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2895623\n"); - end - xrf = 64'hC02FE01000000000; - y = 64'hC6DFFFFDFFFFFFFD; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2896237\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'hBFD0080000200000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2896851\n"); - end - xrf = 64'hB7E0000000FFFFDE; - y = 64'hC8000040FFFFFFFF; - zrf = 64'h3CA25A25EB808CF6; - ans = 64'h3FF00041010003EE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2897465\n"); - end - xrf = 64'h600FFFFFFFFFC002; - y = 64'h8000000000000001; - zrf = 64'h3FF0000000000000; - ans = 64'h3FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2898079\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h400000000000002F; - zrf = 64'h380DF17822F732BD; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2898693\n"); - end - xrf = 64'hB11AD0B8DA26800D; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hC780000000000017; - ans = 64'hC780000000000017; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2899307\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h400E791D9DD9BC2F; - zrf = 64'h8010000000000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2899921\n"); - end - xrf = 64'h81A0000FBFFFFFFF; - y = 64'h4343FFFFFFFFFF7E; - zrf = 64'h401FFF800000007E; - ans = 64'h401FFF800000007E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2900535\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h8010000000000001; - zrf = 64'h3CA0000000000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2901149\n"); - end - xrf = 64'h4D8000004000007F; - y = 64'hBF60000010000001; - zrf = 64'hC340000000000001; - ans = 64'hCCF00000500000C0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2901763\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h3DA00000002001FF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2902377\n"); - end - xrf = 64'h3FDFFFE00000FFFE; - y = 64'h5B962D44BC128284; - zrf = 64'hC1F37FD701772207; - ans = 64'h5B862D2E8ECE77DA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2902991\n"); - end - xrf = 64'h480F000000000006; - y = 64'hBCA0000000000000; - zrf = 64'h3FE0000000000001; - ans = 64'hC4BF000000000006; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2903605\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'hC1F17FFFFFFFFFFF; - zrf = 64'hC02041FFFFFFFFFF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2904219\n"); - end - xrf = 64'h4028629AD7424975; - y = 64'hBCA0000000000001; - zrf = 64'h3CA00001FFFFFC00; - ans = 64'hBCD6629A974249F7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2904833\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'hC1DFFFFFFE000200; - zrf = 64'h8000000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2905447\n"); - end - xrf = 64'hBFDF00000001FFFF; - y = 64'hC80FFFFFFFFFFDBF; - zrf = 64'hC7B978FC409BA3FD; - ans = 64'h47FD68703BF84390; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2906061\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'hBFD0000000000000; - zrf = 64'h0010000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2906675\n"); - end - xrf = 64'hC1ED805BD15C139B; - y = 64'h28901FFFFFFFFFFD; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2907289\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'hBFD0000000000001; - zrf = 64'h4030000800200000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2907903\n"); - end - xrf = 64'h37EFFFFFBC000000; - y = 64'hF040000200000FFF; - zrf = 64'hBFAFFFFFF7FEFFFE; - ans = 64'hE8400001DE000BBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2908517\n"); - end - xrf = 64'hBFFFFFF5FFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FF7FFFAFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2909131\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h40200000FFFFDFFE; - zrf = 64'hAC4F7052B43B96D6; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2909745\n"); - end - xrf = 64'hC3FC000040000000; - y = 64'hBFE0000000000000; - zrf = 64'hBF9FFFFFBFFFFBFF; - ans = 64'h43EC000040000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2910359\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h3CA00003FFFFFFF6; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2910973\n"); - end - xrf = 64'h39CEA5268438722C; - y = 64'h3E4FDFFDFFFFFFFF; - zrf = 64'h3FE0000000FFFFFC; - ans = 64'h3FE0000000FFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2911587\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2912201\n"); - end - xrf = 64'h802FFFC000003FFF; - y = 64'h3D700000000FFFF8; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2912815\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'hBFF0000000000000; - zrf = 64'h3FBF00000000001F; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2913429\n"); - end - xrf = 64'h47E03FFFFFFFF800; - y = 64'hC00001007FFFFFFF; - zrf = 64'h400000000008001E; - ans = 64'hC7F0410481FFF7FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2914043\n"); - end - xrf = 64'h38100003FEFFFFFF; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h3CAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2914657\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h5EBDA64B1F6C454A; - zrf = 64'hBFE000000800001F; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2915271\n"); - end - xrf = 64'h41FFDFFFFF7FFFFE; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hBC639470CFAB75A4; - ans = 64'hC20FDFFFFF7FFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2915885\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'hBFF83A1ED571DC64; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2916499\n"); - end - xrf = 64'h802000004000FFFF; - y = 64'hC00010003FFFFFFE; - zrf = 64'h80110003FFFFFFFE; - ans = 64'h00279FFF008203FB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2917113\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'hC000000000000001; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2917727\n"); - end - xrf = 64'hFFEFFFFFFFFFF01F; - y = 64'h3FDDF7FFFFFFFFFE; - zrf = 64'hC000000000000000; - ans = 64'hFFDDF7FFFFFFF11F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2918341\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'hBF8F7FFFFFFFFFBF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2918955\n"); - end - xrf = 64'hC024C21357A48D0D; - y = 64'hFFF0000000003FF7; - zrf = 64'h41D00017FFFFFFFE; - ans = 64'hFFF8000000003FF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2919569\n"); - end - xrf = 64'h445169266A3DEB8C; - y = 64'hC010000000000001; - zrf = 64'h3CA0000000000000; - ans = 64'hC47169266A3DEB8D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2920183\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h7FDFFF000007FFFF; - zrf = 64'hBFCFFFFFFFFF800E; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2920797\n"); - end - xrf = 64'h43DFFF83FFFFFFFF; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h41E0007FFF000000; - ans = 64'hC40FFF83FFFBFFDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2921411\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h47EFFFFFFFF7FFFE; - zrf = 64'h7FE0000000000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2922025\n"); - end - xrf = 64'h3E400001FFFBFFFF; - y = 64'h3FE77A2166CACFDC; - zrf = 64'h381359BB509306FE; - ans = 64'h3E377A2456091E2C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2922639\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'hC340000000000000; - zrf = 64'hFFF0000000000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2923253\n"); - end - xrf = 64'hBFD000000004007F; - y = 64'h3FDFFFFBFFFFFBFF; - zrf = 64'hBFF0000000000001; - ans = 64'hBFF1FFFFC0007FD1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2923867\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h3CACE893AA2E59D8; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2924481\n"); - end - xrf = 64'h3FB0B636B6EA69D3; - y = 64'h2600000007FFFFBE; - zrf = 64'h3601FFFFFFFFFF7F; - ans = 64'h3601FFFFFFFFFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2925095\n"); - end - xrf = 64'hC550000080000FFF; - y = 64'hFFE0000000000000; - zrf = 64'h0010000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2925709\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h43FFFFFFF000001E; - zrf = 64'h3FF0400200000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2926323\n"); - end - xrf = 64'h41EFFFFFFC000001; - y = 64'hFFE0000000000001; - zrf = 64'h407FC00000000007; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2926937\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'h46452C93D5A9BE1B; - zrf = 64'h4340000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2927551\n"); - end - xrf = 64'h3FA4BFCB07A2886E; - y = 64'h3B1F43C73803FA4C; - zrf = 64'h3FB200FFFFFFFFFF; - ans = 64'h3FB200FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2928165\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'hFFE0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2928779\n"); - end - xrf = 64'h20BFFFFF7EFFFFFE; - y = 64'h43DFFFE000000100; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2929393\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'hFFF0000000000001; - zrf = 64'hC7E0000001FFFFEF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2930007\n"); - end - xrf = 64'h400D2E087C272421; - y = 64'h58200401FFFFFFFE; - zrf = 64'hC3C266610B3228BB; - ans = 64'h583D3557A4073D6B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2930621\n"); - end - xrf = 64'h47EEFFFFFFBFFFFF; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2931235\n"); - end - xrf = 64'h7FF0000000000001; - y = 64'hC054A510735203C8; - zrf = 64'hC3EFFFFFFFFE01FF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2931849\n"); - end - xrf = 64'hC34000001FFFFDFF; - y = 64'h0000000000000000; - zrf = 64'h7FE0000000011FFF; - ans = 64'h7FE0000000011FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2932463\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hBFEFFFFF7FFFFFFE; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2933077\n"); - end - xrf = 64'h1440D7A99B79C195; - y = 64'h3D6000000000100F; - zrf = 64'hC3DFF800007FFFFF; - ans = 64'hC3DFF800007FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2933691\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2934305\n"); - end - xrf = 64'hBFC72574439F0F8D; - y = 64'hBCCE99A34A3E0638; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2934919\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h0010000000000000; - zrf = 64'hC1DF000000000FFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2935533\n"); - end - xrf = 64'h801FFFFFFBFFFFEF; - y = 64'hC340440000000000; - zrf = 64'h40808FFFFFFFFFFE; - ans = 64'h40808FFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2936147\n"); - end - xrf = 64'hBFF60F1DF5DA594A; - y = 64'h0010000000000001; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2936761\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h3FE0000000110000; - zrf = 64'h3FCFFFFFFFFDFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2937375\n"); - end - xrf = 64'hBB212651C58F296A; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h7FD3E0DB33B0C462; - ans = 64'h7FD3E0DB33B0C462; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2937989\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h43C0000000001EFE; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2938603\n"); - end - xrf = 64'h402AFC152BB76278; - y = 64'hC73F7FFFFFFEFFFF; - zrf = 64'hBDD0000080FFFFFF; - ans = 64'hC77A9024D707AD0D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2939217\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h3CA0000000000001; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2939831\n"); - end - xrf = 64'h3CF0100FFFFFFFFE; - y = 64'h3E5FDFFF7FFFFFFE; - zrf = 64'hBFD0000000000000; - ans = 64'hBFD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2940445\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h7FDFFFFE04000000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2941059\n"); - end - xrf = 64'hC3CFCFFFFFFFFFFF; - y = 64'h4043FFFFFFFFBFFF; - zrf = 64'hC010003FFFFFFFFE; - ans = 64'hC423E1FFFFFFC05E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2941673\n"); - end - xrf = 64'hC1E499D3794E5EF8; - y = 64'h3FD0000000000000; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2942287\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h3F0000000080FFFF; - zrf = 64'h7FF000000F7FFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2942901\n"); - end - xrf = 64'h41EFFFFFFFFEFF7F; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h480F7FC000000000; - ans = 64'h480F7FC000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2943515\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hC426783221EF473C; - zrf = 64'h4000000000000000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2944129\n"); - end - xrf = 64'h7FE01FFFFFFFDFFF; - y = 64'h434FFFF00001FFFE; - zrf = 64'h381FF7FFFFF7FFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2944743\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h3FE0000000000000; - zrf = 64'hC010000000000000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2945357\n"); - end - xrf = 64'hF3ABFFF7FFFFFFFF; - y = 64'hBD5EFFBFFFFFFFFE; - zrf = 64'hBCA0000000000001; - ans = 64'h711B1FC0400FFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2945971\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h434FFFFEFFFFFFFD; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2946585\n"); - end - xrf = 64'hBFA0000001FFF7FF; - y = 64'h3E32C8772CF7A110; - zrf = 64'hC150004000200000; - ans = 64'hC150004000200000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2947199\n"); - end - xrf = 64'hC6BFFFFDFFBFFFFE; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2947813\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h407BE20CE424F639; - zrf = 64'h2380003FFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2948427\n"); - end - xrf = 64'h4E4FFF7FFFEFFFFF; - y = 64'h3FF0000000000001; - zrf = 64'h4000000000101000; - ans = 64'h4E4FFF7FFFF00001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2949041\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hBFFFFFFFFFFF01FF; - zrf = 64'h3FF0000000000001; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2949655\n"); - end - xrf = 64'h403FFBFFFFFFFDFF; - y = 64'hFCAF4DA8CA8EDCB6; - zrf = 64'h3FFFFFFFFFEFFFBF; - ans = 64'hFCFF49BF157588E5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2950269\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hC000000000000001; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2950883\n"); - end - xrf = 64'hBFD0000007FF7FFF; - y = 64'hFFDFFFEFFFFFFFEF; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h7FBFFFF00FFEF7EE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2951497\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h4000000000000001; - zrf = 64'h3FEFFFFFFBEFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2952111\n"); - end - xrf = 64'hF6C7FBFFFFFFFFFE; - y = 64'h3F0FF80000200000; - zrf = 64'h38200000000008FE; - ans = 64'hF5E7F6010017FBFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2952725\n"); - end - xrf = 64'hC01FF003FFFFFFFE; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC350000000000007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2953339\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hBCA8A69E52F6A7C2; - zrf = 64'h3FE0002000FFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2953953\n"); - end - xrf = 64'hC670003BFFFFFFFF; - y = 64'h4010000000000000; - zrf = 64'h3F4000008FFFFFFF; - ans = 64'hC690003BFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2954567\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hBFCBFFFFFFFFFFFE; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2955181\n"); - end - xrf = 64'h2E85F2326ACAC7CD; - y = 64'h40200000100000FF; - zrf = 64'h390000001FFFC000; - ans = 64'h390000001FFFC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2955795\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2956409\n"); - end - xrf = 64'hC7F0005FFFFFFFFE; - y = 64'h001FFFFFDFFFEFFF; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h8820005FEFFF97FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2957023\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h4340000000000000; - zrf = 64'hBFF587068DC3E0AA; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2957637\n"); - end - xrf = 64'hB9FFF4E99D3A4249; - y = 64'hF4D0007FFBFFFFFF; - zrf = 64'h402000000000083E; - ans = 64'h6EDFF5E93C89F1B2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2958251\n"); - end - xrf = 64'hE2A0000041FFFFFF; - y = 64'h4340000000000001; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hE5F0000042000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2958865\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h7FFBCB3137A93FEB; - zrf = 64'hBFEFFFF8001FFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2959479\n"); - end - xrf = 64'h37FFFFFFFFFBFFBE; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h41FFFFFFFFFDFFF7; - ans = 64'h41FFFFFFFFFDFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2960093\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h3DCC0000FFFFFFFE; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2960707\n"); - end - xrf = 64'h3ED4000000040000; - y = 64'h47F0000000006FFF; - zrf = 64'hBFE26C979F9A687F; - ans = 64'h46D4000000048BFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2961321\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h7FE0000000000001; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2961935\n"); - end - xrf = 64'hC390000001000000; - y = 64'h74AAA02E49FFE7E3; - zrf = 64'h8000000000000000; - ans = 64'hF84AA02E4BA9EAC8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2962549\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h5D7000001000007F; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2963163\n"); - end - xrf = 64'hC0200007FFFFFDFF; - y = 64'h40036DCAC049B7DE; - zrf = 64'h43D2000001FFFFFF; - ans = 64'h43D2000001FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2963777\n"); - end - xrf = 64'hE93FFE0000000002; - y = 64'h7FF0000000000000; - zrf = 64'hC010000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2964391\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h531002FFFFFFFFFF; - zrf = 64'hA74FF7F000000000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2965005\n"); - end - xrf = 64'h47EFFFC000000002; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'hC150000020040000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2965619\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hC34FFFFFFFFFE3FF; - zrf = 64'h3FD0000000000000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2966233\n"); - end - xrf = 64'hC3DBE28DD099AC7E; - y = 64'h407FFFFFFFFFFFFE; - zrf = 64'h37FFFE0000FFFFFE; - ans = 64'hC46BE28DD099AC7C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2966847\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h8000000000000000; - zrf = 64'hBFE0000000000000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2967461\n"); - end - xrf = 64'h41D000000000001D; - y = 64'h3EFFFEBFFFFFFFFF; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2968075\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hC030000003FFF7FF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2968689\n"); - end - xrf = 64'hCCD1FFFFFFFFF7FF; - y = 64'h47B00000DFFFFFFF; - zrf = 64'hC03000000001000E; - ans = 64'hD4920000FBFFF7FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2969303\n"); - end - xrf = 64'h3807FFFF7FFFFFFE; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'hC000000000000001; - ans = 64'hC000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2969917\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hCC3FFFFFFFFFFBEF; - zrf = 64'hCF4FFFFFFFFC0008; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2970531\n"); - end - xrf = 64'h480FFFC000000200; - y = 64'h8010000000000001; - zrf = 64'hBD11000000000001; - ans = 64'hBD11000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2971145\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hC0B16FFAF4B669F3; - zrf = 64'h3CA0000000000001; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2971759\n"); - end - xrf = 64'hABFFFEFFFC000000; - y = 64'hBDD000008000007F; - zrf = 64'hC0EFFD0000000000; - ans = 64'hC0EFFD0000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2972373\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'hBFD0000000000001; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2972987\n"); - end - xrf = 64'h41CFE0000FFFFFFF; - y = 64'h7FFE000003FFFFFF; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FFE000003FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2973601\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hBCA0000000000001; - zrf = 64'hC00800001FFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2974215\n"); - end - xrf = 64'hBCABFBFFFFFFFFFF; - y = 64'h3FF087050E4FE191; - zrf = 64'h3FC0000024000000; - ans = 64'h3FC0000023FFFFF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2974829\n"); - end - xrf = 64'h0149F402042DF1CE; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2975443\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h3FDFFFFFFFFFFEEF; - zrf = 64'h41FD601EC095C9B3; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2976057\n"); - end - xrf = 64'h41D3E7CF94A31274; - y = 64'hBFD0000000000000; - zrf = 64'h3FB000000FFBFFFF; - ans = 64'hC1B3E7CF94931274; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2976671\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hB81F800000100000; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2977285\n"); - end - xrf = 64'hC1C00001FFFFFBFE; - y = 64'hB7FFFFFFFFFFB800; - zrf = 64'hC448000000001FFF; - ans = 64'hC448000000001FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2977899\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2978513\n"); - end - xrf = 64'h3FFFEFFFFE000000; - y = 64'hC7F76493330323AA; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'hC80758E0E7F358E5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2979127\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hBFE0000000000000; - zrf = 64'h47EFFFE000000001; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2979741\n"); - end - xrf = 64'hEFF00000000077FF; - y = 64'hBADBE97EB9C9AE4B; - zrf = 64'h3817B654678C79D0; - ans = 64'h6ADBE97EB9CA7FA0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2980355\n"); - end - xrf = 64'hC2A4F3FF01FF246C; - y = 64'hBFE0000000000001; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'h4294F3FF01FF206D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2980969\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h43FFFFC0000000FF; - zrf = 64'h41D0000000003FFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2981583\n"); - end - xrf = 64'h52FCE5A153E7E2E9; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hBCAFFFFFFFFE7FFF; - ans = 64'hD2FCE5A153E7E2E7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2982197\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hA8527BA8C2664DC8; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2982811\n"); - end - xrf = 64'hC01D3A4BBE35A328; - y = 64'h380FFFBFFFFFFFDE; - zrf = 64'h3FD8000080000000; - ans = 64'h3FD8000080000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2983425\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hBFF0000000000001; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2984039\n"); - end - xrf = 64'h4E3FFFFFFEFFFF00; - y = 64'h55E0007F7FFFFFFF; - zrf = 64'h4340000000000000; - ans = 64'h6430007F7F7FFB83; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2984653\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hBFD0003FFBFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2985267\n"); - end - xrf = 64'h3800000000000006; - y = 64'hC7EFF00000001FFE; - zrf = 64'hBCA0000001FFFFFF; - ans = 64'hBFFFF0000000200A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2985881\n"); - end - xrf = 64'hBC5FFFFFFFFE0800; + x = 64'h7FE0000000000001; y = 64'hC000000000000000; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE0000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -228619,19 +61485,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -228647,12 +61513,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2986495\n"); + $fwrite(fp,"2634311\n"); end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hC05FFFFFFFDFFFF7; - zrf = 64'h403FBFFFFFFDFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; + x = 64'h381FFFFFFFE0FFFE; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hC34FFFFFFFEFFEFE; + ans = 64'hC34FFFFFFFEFFEFE; rn = 1; rz = 0; rm = 0; @@ -228666,19 +61532,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -228694,12 +61560,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2987109\n"); + $fwrite(fp,"2636325\n"); end - xrf = 64'hC56E00AC42169CC5; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h47E0004000001FFF; - ans = 64'h47E0004000009802; + x = 64'h405000000800007F; + y = 64'h400FFFFFFFC001FF; + z = 64'hC3F00007FFFFFFE0; + ans = 64'hC3F00007FFFFFFE0; rn = 1; rz = 0; rm = 0; @@ -228713,19 +61579,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -228741,810 +61607,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2987723\n"); + $fwrite(fp,"2638339\n"); end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hC0100003FFFFFFDF; - zrf = 64'h0000000000000000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2988337\n"); - end - xrf = 64'hBF6FFC8000000000; - y = 64'h3B4FFFFBFFFBFFFF; - zrf = 64'h41FB680E63FF69F2; - ans = 64'h41FB680E63FF69F2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2988951\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hC010000000000000; - zrf = 64'h8010000000000000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2989565\n"); - end - xrf = 64'h7FF4000003FFFFFF; - y = 64'h80007FFFFFFFFFFD; - zrf = 64'h4010000000000001; - ans = 64'h7FFC000003FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2990179\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hC3C2415F61A098C3; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2990793\n"); - end - xrf = 64'h3F9047FFFFFFFFFF; - y = 64'hC1E00000008000FE; - zrf = 64'hBF9EFFF7FFFFFFFF; - ans = 64'hC180480000C040F1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2991407\n"); - end - xrf = 64'hC8501000003FFFFF; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hBFD0000000000001; - ans = 64'h48801000003FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2992021\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h3810000020000007; - zrf = 64'h3FE47701E81BB120; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2992635\n"); - end - xrf = 64'hBCAFF7FFFFFFFFFF; - y = 64'hC340000000000001; - zrf = 64'h3FF003FFFFFFFFEF; - ans = 64'h4007FDFFFFFFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2993249\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hC020000000000104; - zrf = 64'hFFF0000000000001; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2993863\n"); - end - xrf = 64'hC710000000001800; - y = 64'h666FFE00000001FF; - zrf = 64'hB8E000FFBFFFFFFF; - ans = 64'hED8FFE00000031FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2994477\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h8000000000000001; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2995091\n"); - end - xrf = 64'h4011FFFFDFFFFFFF; - y = 64'hBFEF9C08BE85F180; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'hBFDC7C4CB8F4F190; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2995705\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hFFE0000000000001; - zrf = 64'h4B9000000007C000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2996319\n"); - end - xrf = 64'h407000010001FFFF; - y = 64'h40059E6C85575EAA; - zrf = 64'h2ED13DD9EC8C1C60; - ans = 64'h40859E6DDF40DACC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2996933\n"); - end - xrf = 64'h39FFFFFFFC00000E; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hF9FFFFFFFC00000D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2997547\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'h47F1FFFFFFFFFDFE; - zrf = 64'h421FFFDDFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2998161\n"); - end - xrf = 64'h7FDFC02000000000; - y = 64'hFFF0000000000000; - zrf = 64'h434367E1A214D062; + x = 64'h7FE0000000000001; + y = 64'hC340000000000000; + z = 64'h3CAFFFFFFFFFFFFF; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -229559,19 +61626,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -229587,12 +61654,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2998775\n"); + $fwrite(fp,"2640353\n"); end - xrf = 64'h7FFFFFFFFFFFFFFF; - y = 64'hBB30000000400020; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; + x = 64'h43EC0D35899D926D; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hBCA000027FFFFFFF; + ans = 64'hC74C0D35899D926C; rn = 1; rz = 0; rm = 0; @@ -229606,19 +61673,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -229634,12 +61701,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"2999389\n"); + $fwrite(fp,"2642367\n"); end - xrf = 64'h3FC231C33927C327; - y = 64'h024000008000003F; - zrf = 64'h43CFFFFE1FFFFFFF; - ans = 64'h43CFFFFE1FFFFFFF; + x = 64'hC22000000001FFE0; + y = 64'h176FFFEFFFFFF7FE; + z = 64'h490FFFFFFFF7FFFF; + ans = 64'h490FFFFFFFF7FFFF; rn = 1; rz = 0; rm = 0; @@ -229653,19 +61720,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -229681,12 +61748,59 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3000003\n"); + $fwrite(fp,"2644381\n"); end - xrf = 64'h7FFFFFFFFFFFFFFF; + x = 64'h7FE0000000000001; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2646395\n"); + end + x = 64'h43F01001FFFFFFFF; y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; + z = 64'h40201FDFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -229700,19 +61814,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -229728,12 +61842,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3000617\n"); + $fwrite(fp,"2648409\n"); end - xrf = 64'hCB0020000000007E; - y = 64'hAEEFFFFFFFFFFFBE; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h3FFFFFFFFFFFFFFE; + x = 64'hFFFA2472BB86DDE6; + y = 64'h380000000000800F; + z = 64'hCC2FFFBFFFFFFBFE; + ans = 64'hFFFA2472BB86DDE6; rn = 1; rz = 0; rm = 0; @@ -229747,19 +61861,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -229775,200 +61889,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3001231\n"); + $fwrite(fp,"2650423\n"); end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h0000000000000000; - zrf = 64'h41C07FFFFFFFFEFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3001845\n"); - end - xrf = 64'hC36FFFFFFFFE3FFF; - y = 64'h43400000003FF7FF; - zrf = 64'h4D21F9255625574B; - ans = 64'h4D21F9255625574B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3002459\n"); - end - xrf = 64'hFD61DD32FB8E3B2C; - y = 64'h0000000000000001; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'hBA41DD32FB8E3B2C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3003073\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h3EB6CDE6B789E903; - zrf = 64'hBFB00000001FFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3003687\n"); - end - xrf = 64'hBFD000000000021F; + x = 64'h7FEFFFFFFFFFFFFF; y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hBCFFFFFBFFFEFFFF; - ans = 64'hBCFFFFFBFFFEFFFF; + z = 64'h4340000000000000; + ans = 64'h4340000000000002; rn = 1; rz = 0; rm = 0; @@ -229982,19 +61908,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -230010,106 +61936,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3004301\n"); + $fwrite(fp,"2652437\n"); end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h401FFFFFBFC00000; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3004915\n"); - end - xrf = 64'h42100FFFFFF80000; - y = 64'h404000000100003F; - zrf = 64'h6E800003FFFE0000; - ans = 64'h6E800003FFFE0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3005529\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; + x = 64'hFFD0007FFFFFFFFF; y = 64'h0010000000000001; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; + z = 64'h43BFF293676FA42F; + ans = 64'h43BFF293676FA42F; rn = 1; rz = 0; rm = 0; @@ -230123,19 +61955,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -230151,12 +61983,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3006143\n"); + $fwrite(fp,"2654451\n"); end - xrf = 64'hC7EFFFFFFFF7FFFF; - y = 64'h1BD000FBFFFFFFFE; - zrf = 64'h3FF0000000000000; - ans = 64'h3FF0000000000000; + x = 64'hCF6FFFFFEFFFFFFB; + y = 64'hC3FFFBF800000000; + z = 64'h3FB0001010000000; + ans = 64'h537FFBF7F00203FB; rn = 1; rz = 0; rm = 0; @@ -230170,19 +62002,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -230198,200 +62030,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3006757\n"); + $fwrite(fp,"2656465\n"); end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hBFF0000000000017; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3007371\n"); - end - xrf = 64'hC02FFFFFFFBFFEFE; - y = 64'hFFE000007FF7FFFF; - zrf = 64'hC800008000000400; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3007985\n"); - end - xrf = 64'h3DFFFF7FFEFFFFFF; - y = 64'h3CA0000000000000; - zrf = 64'h8010000000000000; - ans = 64'h3AAFFF7FFEFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3008599\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hBCAFFFFFDFDFFFFF; - zrf = 64'hC00FFFDFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3009213\n"); - end - xrf = 64'h3FCFFFFFFFFFEEFE; + x = 64'h7FEFFFFFFFFFFFFF; y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hBE8FFFFFF01FFFFF; - ans = 64'hBE8FFFFFEFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -230405,19 +62049,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -230433,200 +62077,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3009827\n"); + $fwrite(fp,"2658479\n"); end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h4D70000000040020; - zrf = 64'hC340000000000000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3010441\n"); - end - xrf = 64'h4804036E90673318; - y = 64'hC490001000000010; - zrf = 64'hBFC0000002FFFFFE; - ans = 64'hCCA4038293D5C393; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3011055\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h3FD0000000000000; - zrf = 64'h7FE0000000000000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3011669\n"); - end - xrf = 64'h37EFFFFFFFF0001F; - y = 64'hFFDF23B774D41560; - zrf = 64'h3FE0000000000001; - ans = 64'hF7DF23B774C483A2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3012283\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; + x = 64'h3FAFFFFFFFFBFEFF; y = 64'h3FD0000000000001; - zrf = 64'hC02EFFFFFFFDFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; + z = 64'h43F0001FFEFFFFFF; + ans = 64'h43F0001FFEFFFFFF; rn = 1; rz = 0; rm = 0; @@ -230640,19 +62096,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -230668,12 +62124,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3012897\n"); + $fwrite(fp,"2660493\n"); end - xrf = 64'h0010000008000100; - y = 64'h384000007FFF0000; - zrf = 64'h43D7FFFFFFFFF7FF; - ans = 64'h43D7FFFFFFFFF7FF; + x = 64'h3FEFFFFFFE0007FF; + y = 64'h43F70A25E925FA1F; + z = 64'h47F7FC40693B3066; + ans = 64'h47F7FC40693B3066; rn = 1; rz = 0; rm = 0; @@ -230687,19 +62143,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -230715,857 +62171,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3013511\n"); + $fwrite(fp,"2662507\n"); end - xrf = 64'h3418CAE9C47A6455; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h8000000000000001; - ans = 64'h3408CAE9C47A6453; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3014125\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h41DC1D360A4CE088; - zrf = 64'h47F396D52218D15D; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3014739\n"); - end - xrf = 64'h406FF800000FFFFF; - y = 64'h3FE0000000000001; - zrf = 64'h3FFFF8000000007E; - ans = 64'h40603BF000080001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3015353\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h37EFFFFFFFFFFFFF; - zrf = 64'hC010000000000001; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3015967\n"); - end - xrf = 64'h40BFFBFFFFBFFFFF; - y = 64'h417DE0C0C0105BC4; - zrf = 64'h3F9FFFFFDFFFFEFF; - ans = 64'h424DDD04A7BC9C36; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3016581\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h4340000000000001; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3017195\n"); - end - xrf = 64'h00101FFFFFFBFFFF; - y = 64'h0F653D345B988780; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3017809\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h3FF0000000000000; - zrf = 64'hBFC0000080004000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3018423\n"); - end - xrf = 64'hC3D00000000FBFFF; - y = 64'hC03FFFFFFFB7FFFE; - zrf = 64'h37EF000000000000; - ans = 64'h441FFFFFFFD77FFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3019037\n"); - end - xrf = 64'hC18FFFFF8001FFFF; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3019651\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hBFC000001FFFFFE0; - zrf = 64'h37E0000000000000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3020265\n"); - end - xrf = 64'h3FF7FFF7FFFFFFFE; - y = 64'h4000000000000000; - zrf = 64'h4340001000000800; - ans = 64'h4340001000000801; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3020879\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hBE1202812D66086A; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3021493\n"); - end - xrf = 64'hC01BDC176961CDDF; - y = 64'h41EFFFFFFBFFEFFF; - zrf = 64'h29C00021FFFFFFFF; - ans = 64'hC21BDC1765E63D03; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3022107\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3022721\n"); - end - xrf = 64'h41C000003FFEFFFF; - y = 64'hC7FFFFFC003FFFFE; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'hC9CFFFFC803DEFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3023335\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h41E007FFF7FFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3023949\n"); - end - xrf = 64'h9CDFFFFF8003FFFF; - y = 64'hC3CFFFF7FFFFFFFF; - zrf = 64'h41D000011FFFFFFF; - ans = 64'h41D000011FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3024563\n"); - end - xrf = 64'h40BFFFFFFFFF9FFF; - y = 64'h4010000000000001; - zrf = 64'h7FEFFFFFFFFFFFFE; + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; ans = 64'h7FEFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -231580,19 +62190,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -231608,4852 +62218,810 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3025177\n"); + $fwrite(fp,"2664521\n"); end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h41F00080FFFFFFFF; - zrf = 64'h3FE00000000043FE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3025791\n"); - end - xrf = 64'hC0116A3A0E8BD9D8; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h3FD0000007FFFFF0; - ans = 64'hC0414A3A0E7BD9D8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3026405\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hD26FFE3FFFFFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3027019\n"); - end - xrf = 64'h402FFFFFFFDFFFFC; - y = 64'hBC1A0EF14D39976E; - zrf = 64'hC0776D17463EB959; - ans = 64'hC0776D17463EB959; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3027633\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h4340000000000001; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3028247\n"); - end - xrf = 64'hC800003FFFFFF7FF; - y = 64'hBFBFFFDFF7FFFFFE; - zrf = 64'h3CA0000000000000; - ans = 64'h47D0002FFBBFE7FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3028861\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h41DE8439E1A9A3DA; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3029475\n"); - end - xrf = 64'hFFDF39CFA8A03BE2; - y = 64'hC3D000000040003E; - zrf = 64'h400C000000000800; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3030089\n"); - end - xrf = 64'h37E003EFFFFFFFFF; - y = 64'h7FE0000000000000; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3030703\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hC04FFE000007FFFF; - zrf = 64'hBD8EFFFFFFFFFFDF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3031317\n"); - end - xrf = 64'h7FE173412B78E0FE; - y = 64'h7FE0000000000001; - zrf = 64'h43AFFFFFF7FFF000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3031931\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h4316F79517C28E75; - zrf = 64'hBFF0000000000000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3032545\n"); - end - xrf = 64'hC02200000000003F; - y = 64'h4010007FFFFFFFFF; - zrf = 64'hB8100001FFFFFF00; - ans = 64'hC04200900000003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3033159\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h7FF0000000000000; - zrf = 64'h4000000000000000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3033773\n"); - end - xrf = 64'hC5CC79F66E8517AD; - y = 64'h3DAFBFFFFFFFFFDE; - zrf = 64'h0010000000000001; - ans = 64'hC38C410281A80D5F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3034387\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h7FF0000000000001; - zrf = 64'h7FD0D5BD4FCDC113; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3035001\n"); - end - xrf = 64'hAC400001000FFFFE; - y = 64'hC00FFFFFE0003FFE; - zrf = 64'h3FDFFEFFFFFFFFFD; - ans = 64'h3FDFFEFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3035615\n"); - end - xrf = 64'h40BFFFFF0000003F; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h4340000000000001; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3036229\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hFFDFFFFFEFFFFFFF; - zrf = 64'hBC157D122DBD3C91; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3036843\n"); - end - xrf = 64'h409FFC0000000002; - y = 64'h8000000000000000; - zrf = 64'hB8020D0B3462BA3F; - ans = 64'hB8020D0B3462BA3F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3037457\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h40B0004003FFFFFF; - zrf = 64'hBFE0000000000001; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3038071\n"); - end - xrf = 64'h4030FBFFFFFFFFFF; - y = 64'h40A8000000000010; - zrf = 64'h6560001FFC000000; - ans = 64'h6560001FFC000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3038685\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h3FF0000000000001; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3039299\n"); - end - xrf = 64'hBFC0000000000002; - y = 64'h400FFFF80000000F; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hBFDFFFF800000013; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3039913\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h8010000000000000; - zrf = 64'hBF497D946A140E35; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3040527\n"); - end - xrf = 64'h3FCFFFFFC8000000; - y = 64'h40429DE6F85FE585; - zrf = 64'hBD33E8B29443F848; - ans = 64'h40229DE6D7CB912B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3041141\n"); - end - xrf = 64'hC0004000000003FF; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h401FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3041755\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h1ED0088000000000; - zrf = 64'h43C0004000000800; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3042369\n"); - end - xrf = 64'h801000FFDFFFFFFF; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'hBCAFFFFFFFFFBEFE; - ans = 64'hBCAFFFFFFFFFBEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3042983\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hC5AFFEFFFFFEFFFF; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3043597\n"); - end - xrf = 64'h43CC000000008000; - y = 64'hBF9FEFFFFFFFEFFE; - zrf = 64'h5560000800000FFE; - ans = 64'h5560000800000FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3044211\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3044825\n"); - end - xrf = 64'h801FE00000000FFF; - y = 64'hFF0003FDFFFFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3045439\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hC3EFFFFFFFF0003E; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3046053\n"); - end - xrf = 64'h90B67083F2F3B2BE; - y = 64'h8021AA0E74B7BE9A; - zrf = 64'h344A4B5F400DAE2F; - ans = 64'h344A4B5F400DAE2F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3046667\n"); - end - xrf = 64'h434FFFFF8000003E; - y = 64'hBFD0000000000001; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'hC32FFFFF80000038; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3047281\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h38200000040FFFFF; - zrf = 64'h45BEFFFFEFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3047895\n"); - end - xrf = 64'hC3D000000001FFDE; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hC80FFFFFFFFDF800; - ans = 64'hC80FFFFFFFFDF800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3048509\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h3801FFFFF7FFFFFF; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3049123\n"); - end - xrf = 64'hC0B000000000100E; - y = 64'h43FFFFFBFFFFEFFF; - zrf = 64'h40200000000FFEFF; - ans = 64'hC4BFFFFC0000101B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3049737\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hBFE0000000000001; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3050351\n"); - end - xrf = 64'hC47F9B896EE345AF; - y = 64'hB7FE6C64EA47F3E0; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3050965\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h16FFFC03FFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3051579\n"); - end - xrf = 64'h41C0000082000000; - y = 64'h41E01FFFFFFBFFFF; - zrf = 64'hC05FFFFFFFF00001; - ans = 64'h43B0200082FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3052193\n"); - end - xrf = 64'h3FFFF800003FFFFE; - y = 64'hBFF0000000000000; - zrf = 64'h4000000000000000; - ans = 64'h3F5FFFFF00000800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3052807\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h381FFFF800FFFFFE; - zrf = 64'hBFE7942C107C146D; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3053421\n"); - end - xrf = 64'h0000EC4C3D4CE00C; - y = 64'hBFF0000000000001; - zrf = 64'hC7F0020000000003; - ans = 64'hC7F0020000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3054035\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hFFEFFFFFBFFFDFFF; - zrf = 64'hBCA0000000000000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3054649\n"); - end - xrf = 64'hC0CDFFFFEFFFFFFE; - y = 64'h3EBFFFFFFE800000; - zrf = 64'h400000000BFFFFFF; - ans = 64'h3FFF880018459FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3055263\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hC000000000000000; - zrf = 64'h3FD0000000000000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3055877\n"); - end - xrf = 64'hB7EFBFEFFFFFFFFF; - y = 64'hC01FFBFFFFF7FFFF; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3056491\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hC000000000000001; - zrf = 64'h3F3FFFFFFFFBFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3057105\n"); - end - xrf = 64'hBC1A7DA73DBA86FA; - y = 64'hBFB0000002FFFFFF; - zrf = 64'h384EFFFFFFFFFFFE; - ans = 64'h3BDA7DA742B21654; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3057719\n"); - end - xrf = 64'hC07D6677D809944E; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h3FF0000000000001; - ans = 64'h409D6A77D809944C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3058333\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hBFBFFFFFF8001FFF; - zrf = 64'h3B1FC0000000000F; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3058947\n"); - end - xrf = 64'h3FFFFFFFFFFFC00E; - y = 64'hC010000000000000; - zrf = 64'hC1C0000000403FFE; - ans = 64'hC1C0000004403FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3059561\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h4000000200001000; - zrf = 64'h8010000000000001; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3060175\n"); - end - xrf = 64'hD50000000000FFFF; - y = 64'h41D007FFFFBFFFFF; - zrf = 64'hFFF0000000800400; - ans = 64'hFFF8000000800400; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3060789\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h3CA0000000000001; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3061403\n"); - end - xrf = 64'hC026021B608EA2C6; - y = 64'hBFE00000001FFFFD; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3062017\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hC340000000000000; - zrf = 64'h37EFFEFBFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3062631\n"); - end - xrf = 64'h4E82000000000010; - y = 64'hC1D2D177358C80A2; - zrf = 64'hC03FFFFFFFBFFC00; - ans = 64'hD0652BA61C3E10C9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3063245\n"); - end - xrf = 64'hC346D9C6FAF76368; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h46A6D9C6FAF76367; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3063859\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hC3CFFFFFF800000F; - zrf = 64'h7FFFFFEFFFFFFFBF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3064473\n"); - end - xrf = 64'hB54BFFE5FD756E11; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h674E709D89CD1045; - ans = 64'h674E709D89CD1045; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3065087\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hB7FFFFFFFBFFFFF7; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3065701\n"); - end - xrf = 64'h3FC00003FC000000; - y = 64'h41CFFFFFFF0007FE; - zrf = 64'h8010007FFFFBFFFF; - ans = 64'h41A00003FB8003DF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3066315\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3066929\n"); - end - xrf = 64'h28157F6040613C66; - y = 64'h705800FFFFFFFFFE; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'h588020342B4AF055; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3067543\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h41C01FFFFBFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3068157\n"); - end - xrf = 64'hBFFFFFFFFE000FFE; - y = 64'h41E1327FFABA4463; - zrf = 64'hB7FFFFFFFFC00000; - ans = 64'hC1F1327FF9A724FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3068771\n"); - end - xrf = 64'hC05FFFFF80000000; - y = 64'hFFF0000000000001; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3069385\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h3FC4E9D3D378B53D; - zrf = 64'h3FA000200000000F; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3069999\n"); - end - xrf = 64'hC06FFFF7FFFFFFFB; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hC030001FFFFFFFFD; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3070613\n"); - end - xrf = 64'h7FFFFFFFFFFFFFFE; - y = 64'h403F5FC3BCD9FA44; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3071227\n"); - end - xrf = 64'hC02E18F44A3E03BD; - y = 64'h3FA00000FFFFFFF8; - zrf = 64'hFFF00000000FFFFF; - ans = 64'hFFF80000000FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3071841\n"); - end - xrf = 64'h8000000000000000; - y = 64'h0000000000000001; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h000FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3072455\n"); - end - xrf = 64'hBFEA884E50247B88; - y = 64'hC39A5B2CF6AC3C47; - zrf = 64'hC010000000000000; - ans = 64'h4395DA5887C3E2F7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3073069\n"); - end - xrf = 64'h8000000000000000; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h43D02FFFFFFFFFFF; - ans = 64'h43D02FFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3073683\n"); - end - xrf = 64'hC1F3FBFFFFFFFFFF; - y = 64'h3CA00000000017FF; - zrf = 64'hDE3BFDFFFFFFFFFF; - ans = 64'hDE3BFDFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3074297\n"); - end - xrf = 64'h3FCFFFFFEFFFFFBF; - y = 64'h0010000000000000; - zrf = 64'h3FD0000000000000; - ans = 64'h3FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3074911\n"); - end - xrf = 64'h8000000000000000; - y = 64'hC1F457645C6077D2; - zrf = 64'h41CE000007FFFFFF; - ans = 64'h41CE000007FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3075525\n"); - end - xrf = 64'hED901FFFFFFFFFF7; - y = 64'h0010000000000001; - zrf = 64'h43C0003FFFFFF7FF; - ans = 64'h43C0003FFFFFF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3076139\n"); - end - xrf = 64'h8000000000000000; - y = 64'hC030000040400000; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3076753\n"); - end - xrf = 64'h3FC021FFFFFFFFFE; - y = 64'hBCAF7FFFEFFFFFFE; - zrf = 64'hC341F7FFFFFFFFFE; - ans = 64'hC341F7FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3077367\n"); - end - xrf = 64'h8000000000000000; - y = 64'h3CA0000000000000; - zrf = 64'h0000000000000000; - ans = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3077981\n"); - end - xrf = 64'h47EFFFFFFF804000; - y = 64'h802FFFFFFC100000; - zrf = 64'hC000000000000001; - ans = 64'hC000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3078595\n"); - end - xrf = 64'h8000000000000000; - y = 64'h3CA0000000000001; - zrf = 64'hC032000000000FFF; - ans = 64'hC032000000000FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3079209\n"); - end - xrf = 64'hFFF0100000007FFF; - y = 64'hBE50007F80000000; - zrf = 64'hC3450907904A895D; - ans = 64'hFFF8100000007FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3079823\n"); - end - xrf = 64'h7FEFC3FFFFFFFFFF; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h3CA0000000000001; - ans = 64'h7CAFC3FFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3080437\n"); - end - xrf = 64'h8000000000000000; - y = 64'hC3FBC0311875347E; - zrf = 64'h404740F81BE91948; - ans = 64'h404740F81BE91948; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3081051\n"); - end - xrf = 64'h40F0003FC0000000; - y = 64'h3FD0000000000000; - zrf = 64'h41E9224C4FC48A71; - ans = 64'h41E922544FE46A71; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3081665\n"); - end - xrf = 64'h8000000000000000; - y = 64'h7FF001FFFFFF7FFF; - zrf = 64'h7FE0000000000001; - ans = 64'h7FF801FFFFFF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3082279\n"); - end - xrf = 64'h3FC0020007FFFFFE; - y = 64'h3FFD07336C3C07A2; - zrf = 64'hAE1A599530074107; - ans = 64'h3FCD0AD4612D28D5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3082893\n"); - end - xrf = 64'h8000000000000000; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3083507\n"); - end - xrf = 64'h001BB71BCC644518; - y = 64'h3CCA1657CF69F990; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3084121\n"); - end - xrf = 64'h8000000000000000; - y = 64'h3FE0000000000000; - zrf = 64'hFFFB22B4429E5973; - ans = 64'hFFFB22B4429E5973; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3084735\n"); - end - xrf = 64'hC6503FFFFFFFFFEF; - y = 64'hC80FFFFF803FFFFE; - zrf = 64'h4800100002000000; - ans = 64'h4E703FFFBF207FEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3085349\n"); - end - xrf = 64'h404FFFFFFF802000; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h404FFFFFFF801FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3085963\n"); - end - xrf = 64'h8000000000000000; - y = 64'h43DFFE0000000002; - zrf = 64'h3FCFFFC00001FFFF; - ans = 64'h3FCFFFC00001FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3086577\n"); - end - xrf = 64'h37EFF003FFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h455000003FFFEFFF; - ans = 64'h455000003FFFEFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3087191\n"); - end - xrf = 64'h8000000000000000; - y = 64'hC1D4D2909DF566D4; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3087805\n"); - end - xrf = 64'hCC70E9EB1B349793; - y = 64'h405FC00000000020; - zrf = 64'hC26100003FFFFFFE; - ans = 64'hCCE0C81744FE2E75; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3088419\n"); - end - xrf = 64'h8000000000000000; + x = 64'hBFD3CDC9C82B0594; y = 64'h3FF0000000000001; - zrf = 64'hFFEFFFFFFFFFFFFF; + z = 64'h801FFFFF7FF7FFFF; + ans = 64'hBFD3CDC9C82B0595; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2666535\n"); + end + x = 64'h41EFFFFFFFEFFFF0; + y = 64'h434FFFFFFFFAFFFF; + z = 64'h37EF5CAE32DE4414; + ans = 64'h454FFFFFFFEAFFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2668549\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2670563\n"); + end + x = 64'h0014E05E573858BA; + y = 64'h4010000000000000; + z = 64'hDA8000003FFFBFFE; + ans = 64'hDA8000003FFFBFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2672577\n"); + end + x = 64'h380FFEFFFFFDFFFF; + y = 64'hC02F4361FFA13654; + z = 64'hC0CFFFFE0000007F; + ans = 64'hC0CFFFFE0000007F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2674591\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h4340000000000001; + z = 64'hC340000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2676605\n"); + end + x = 64'h3FB00000003FBFFF; + y = 64'h7FE0000000000000; + z = 64'h4F81FFFFFFFFDFFF; + ans = 64'h7FA00000003FBFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2678619\n"); + end + x = 64'h43412867894A0DC5; + y = 64'hC3F94739873DE8C1; + z = 64'h3FCBFFDFFFFFFFFF; + ans = 64'hC74B1B82C2ED1473; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2680633\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h7FF0000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2682647\n"); + end + x = 64'hBFC00003FE000000; + y = 64'h8000000000000000; + z = 64'h43D68C73218D34AD; + ans = 64'h43D68C73218D34AD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2684661\n"); + end + x = 64'h4DF2000000200000; + y = 64'hBCAE00001FFFFFFE; + z = 64'h428FFFFFFF800FFE; + ans = 64'hCAB0E000121DFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2686675\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'h8010000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hC010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2688689\n"); + end + x = 64'h7FF07FFDFFFFFFFE; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hBFBB25BD3D7D1912; + ans = 64'h7FF87FFDFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2690703\n"); + end + x = 64'h47900000081FFFFF; + y = 64'h5760040000001FFF; + z = 64'h405FFFC03FFFFFFF; + ans = 64'h5F000400082227FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2692717\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hBFD0000000000000; + z = 64'hBFF0000000000001; + ans = 64'hFFCFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2694731\n"); + end + x = 64'hB7F001000000003E; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hB7F00000004001FF; + ans = 64'hB7DFFE0001000782; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2696745\n"); + end + x = 64'hC01FC000FFFFFFFF; + y = 64'hBFEFF0001FFFFFFF; + z = 64'h406BFFEFFFFFFFFE; + ans = 64'h406CFD7108FA0006; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2698759\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hBFF0000000000000; + z = 64'h4340000000000000; ans = 64'hFFEFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -236468,19 +63036,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -236496,12 +63064,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3089033\n"); + $fwrite(fp,"2700773\n"); end - xrf = 64'hECD000FDFFFFFFFF; - y = 64'h40800000000003DE; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hED6000FE000003DD; + x = 64'h42CF0007FFFFFFFE; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h43FFFB7FFFFFFFFF; + ans = 64'h43FFFB783FFDFFFF; rn = 1; rz = 0; rm = 0; @@ -236515,19 +63083,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -236543,12 +63111,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3089647\n"); + $fwrite(fp,"2702787\n"); end - xrf = 64'h8000000000000000; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h22DFFFFFFEFFF7FF; - ans = 64'h22DFFFFFFEFFF7FF; + x = 64'hB80FFDFFFFFEFFFF; + y = 64'h381000000040001F; + z = 64'h3FD00000003FFFFF; + ans = 64'h3FD00000003FFFFF; rn = 1; rz = 0; rm = 0; @@ -236562,19 +63130,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -236590,12 +63158,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3090261\n"); + $fwrite(fp,"2704801\n"); end - xrf = 64'hC000010003FFFFFF; - y = 64'h43D0080000000800; - zrf = 64'h5B3C1ACD83585189; - ans = 64'h5B3C1ACD83585189; + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -236609,19 +63177,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -236637,12 +63205,2362 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3090875\n"); + $fwrite(fp,"2706815\n"); end - xrf = 64'hC7EFFBFFFFFFFEFF; + x = 64'h5760000004000001; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h3FFFFFFF7FFFE000; + ans = 64'hD790000004000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2708829\n"); + end + x = 64'hC57F7FFBFFFFFFFF; + y = 64'hBFC0200004000000; + z = 64'h7FFFFFFFFF9FFFFE; + ans = 64'h7FFFFFFFFF9FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2710843\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2712857\n"); + end + x = 64'hBF500000000803FF; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h3FFB0E4708FCD9C5; + ans = 64'h7F500000000803FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2714871\n"); + end + x = 64'hC34FFFFFFF7FBFFE; + y = 64'h37F0000000401000; + z = 64'h40AFFFFE0000007F; + ans = 64'h40AFFFFE0000007F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2716885\n"); + end + x = 64'h7FEFFFFFFFFFFFFF; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2718899\n"); + end + x = 64'h37F0000020000FFE; + y = 64'h0000000000000001; + z = 64'hB7E000FFEFFFFFFF; + ans = 64'hB7E000FFEFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2720913\n"); + end + x = 64'h401FFFFFF7DFFFFE; + y = 64'hDD9000000010003F; + z = 64'h380FFF7F7FFFFFFF; + ans = 64'hDDBFFFFFF800007C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2722927\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC33FFFFFFFFFFFF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2724941\n"); + end + x = 64'hC060003FFFFF7FFE; + y = 64'h3CA0000000000001; + z = 64'hC02000FFFEFFFFFE; + ans = 64'hC02000FFFF000006; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2726955\n"); + end + x = 64'h3FDFFFFFFFBEFFFF; + y = 64'h5A9100000003FFFF; + z = 64'h8018800000000000; + ans = 64'h5A80FFFFFFE177FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2728969\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h3FDFFFFFFFFFFFFF; + 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,"2730983\n"); + end + x = 64'hA13FFFFFFFBFFFF6; + y = 64'h3FE0000000000001; + z = 64'hC3C0100FFFFFFFFF; + ans = 64'hC3C0100FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2732997\n"); + end + x = 64'hC0F00000001F7FFF; + y = 64'hB7F4201E7C0834E7; + z = 64'h450F8003FFFFFFFE; + ans = 64'h450F8003FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2735011\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2737025\n"); + end + x = 64'h40318E6058B65A02; + y = 64'h4000000000000000; + z = 64'hB9B00000000FFDFF; + ans = 64'h40418E6058B65A02; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2739039\n"); + end + x = 64'h41E007FFFF800000; + y = 64'h4EDFFEFBFFFFFFFF; + z = 64'h3F6000002001FFFF; + ans = 64'h50D0077DBE80040F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2741053\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h4010000000000001; + z = 64'hBFF0000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2743067\n"); + end + x = 64'h480FF83FFFFFFFFE; + y = 64'h4340000000000000; + z = 64'hC1CFFFFFFFFFFFC1; + ans = 64'h4B5FF83FFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2745081\n"); + end + x = 64'hC7EFFFFDFFFEFFFF; + y = 64'hBE6FFFFFFFBFFF7E; + z = 64'hB81000000037FFFE; + ans = 64'h466FFFFDFFBEFF81; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2747095\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h7FE0000000000001; + z = 64'h4340000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2749109\n"); + end + x = 64'h4220000000808000; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hC80AECD2C45760C7; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2751123\n"); + end + x = 64'h37E000000001FFFF; + y = 64'h434001000007FFFF; + z = 64'h38100007FFE00000; + ans = 64'h3B300100000A0022; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2753137\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'h8000000000000000; + 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,"2755151\n"); + end + x = 64'h3F5FFF80003FFFFF; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hBFCFFFFBFFFFFFBF; + ans = 64'hBFCFFFFBFFFFFFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2757165\n"); + end + x = 64'h40EFFFFF77FFFFFE; + y = 64'hB7E00C0000000000; + z = 64'hBFF705F4048A86F0; + ans = 64'hBFF705F4048A86F0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2759179\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hBCA0000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hFC9FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2761193\n"); + end + x = 64'h7FF0000FFFEFFFFE; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h37F00000000040FE; + ans = 64'h7FF8000FFFEFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2763207\n"); + end + x = 64'hB6C00000FFFFE000; + y = 64'h408FFEFFFFFFC000; + z = 64'h3F2E0000001FFFFF; + ans = 64'h3F2E0000001FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2765221\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hBFE0000000000000; + z = 64'h3FF0000000000001; + ans = 64'hFFDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2767235\n"); + end + x = 64'h3DC03FFFFFFF7FFE; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hC3FFFF7FFFFFFF00; + ans = 64'hC3FFFF7FFFFFFF00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2769249\n"); + end + x = 64'h43FFFFFC0000FFFE; + y = 64'hBFFB2CF1E73D8A09; + z = 64'hBFD4AF8A8F842F1A; + ans = 64'hC40B2CEE81A02687; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2771263\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hBFFFFFFFFFFFFFFE; + 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,"2773277\n"); + end + x = 64'hC03FFFFFFFFFFBEF; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hC07FFFFE02000000; + ans = 64'hC077FFFE02000104; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2775291\n"); + end + x = 64'hBCA0001008000000; + y = 64'h41C0000000000FDF; + z = 64'h3FEAC3E63849250D; + ans = 64'h3FEAC3E6184904FD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2777305\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hC01FFFFFFFFFFFFE; + 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,"2779319\n"); + end + x = 64'h3F0FF7FFFFFFC000; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h3FEEFFFFFFFF7FFF; + ans = 64'hC26FF7FFFFFFA0FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2781333\n"); + end + x = 64'hC01FFFFFFFFFEFBF; + y = 64'h801000000010FFFF; + z = 64'hC3D0003FFFFFFF80; + ans = 64'hC3D0003FFFFFFF80; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2783347\n"); + end + x = 64'h7FEFFFFFFFFFFFFE; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2785361\n"); + end + x = 64'h3FC3F637647C8A8C; + y = 64'hFFF0000000000001; + z = 64'hBF1FF0003FFFFFFE; + 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,"2787375\n"); + end + x = 64'hBFF9BABB71F7F8B0; + y = 64'hB80FFFFFDFFFFFEE; + z = 64'hBB7000000000003E; + ans = 64'hBB7000000000003E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2789389\n"); + end + x = 64'h7FF0000000000000; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2791403\n"); + end + x = 64'hBFC3FC9335D22F67; + y = 64'h0010000000000001; + z = 64'h41CFFFC000FFFFFF; + ans = 64'h41CFFFC000FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2793417\n"); + end + x = 64'h3F1FFFFFE0000004; + y = 64'h426CEDD14CA226B4; + z = 64'h41E00007FFFF7FFF; + ans = 64'h41E0E776897D22AA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2795431\n"); + end + x = 64'h7FF0000000000000; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2797445\n"); + end + x = 64'hB81D83911AC173B1; + y = 64'h3FD0000000000000; + z = 64'h800FFFFFFDFDFFFF; + ans = 64'hB7FD83911AC173B1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2799459\n"); + end + x = 64'hC1DC0000000FFFFF; + y = 64'hBB9FFBFFFFFDFFFF; + z = 64'h802992FB76E672FC; + ans = 64'h3D8BFC80000E3DFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2801473\n"); + end + x = 64'h7FF0000000000000; + y = 64'h3FE0000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2803487\n"); + end + x = 64'hC08FFFFFFFFE001E; + y = 64'h3FF0000000000000; + z = 64'hC070220000000000; + ans = 64'hC094087FFFFF000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2805501\n"); + end + x = 64'hC34003FFFFFFFDFE; + y = 64'h43C0000000200000; + z = 64'h961FFFFFFFFFFFC3; + ans = 64'hC7100400002005FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2807515\n"); + end + x = 64'h7FF0000000000000; y = 64'h4000000000000001; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'hC7FFFBFFFFFFFF01; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -236656,19 +65574,6599 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2809529\n"); + end + x = 64'h8003D79E3B794CCF; + y = 64'h4010000000000000; + z = 64'h3FD008000FFFFFFF; + ans = 64'h3FD008000FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2811543\n"); + end + x = 64'h3F200005FFFFFFFF; + y = 64'h801FF00004000000; + z = 64'hC3D002000003FFFF; + ans = 64'hC3D002000003FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2813557\n"); + end + x = 64'h7FF0000000000000; + y = 64'h4340000000000001; + z = 64'h3FF0000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2815571\n"); + end + x = 64'hBFB58386CB4FD276; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hC72000200003FFFE; + ans = 64'hC72000200003FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2817585\n"); + end + x = 64'h4D4FFFFFFFD7FFFF; + y = 64'hBFF2228BAA70FAE0; + z = 64'h2F00010000000001; + ans = 64'hCD52228BAA5A4FB1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2819599\n"); + end + x = 64'h7FF0000000000000; + y = 64'h7FF0000000000000; + z = 64'hC340000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2821613\n"); + end + x = 64'hB7E92B1594C31403; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hB81FFFFFFFFFF807; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2823627\n"); + end + x = 64'h47EFE00003FFFFFF; + y = 64'hC36E9EBBDD2B9332; + z = 64'h5FE200000001FFFF; + ans = 64'h5FE200000001FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2825641\n"); + end + x = 64'h7FF0000000000000; + y = 64'h8010000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2827655\n"); + end + x = 64'h4060000000080FFE; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h47FFFC000FFFFFFF; + ans = 64'h47FFFC000FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2829669\n"); + end + x = 64'h3FC765C9DCA95998; + y = 64'h41EFFFF7FFFFFDFF; + z = 64'h758FFDFF80000000; + ans = 64'h758FFDFF80000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2831683\n"); + end + x = 64'h7FF0000000000000; + y = 64'hBFD0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2833697\n"); + end + x = 64'hCD41FFFFFFFE0000; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hB5400FFFFFDFFFFF; + ans = 64'h4D31FFFFFFFDFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2835711\n"); + end + x = 64'hC34FFDFFFFFF7FFF; + y = 64'h360FFFFFFFFFFFBE; + z = 64'h3F5FFFFEFFFFFFFC; + ans = 64'h3F5FFFFEFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2837725\n"); + end + x = 64'h7FF0000000000000; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2839739\n"); + end + x = 64'hC3368331494C07F2; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h41D0000007FFFFFF; + ans = 64'h43468331694C0801; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2841753\n"); + end + x = 64'h3FE0000000020002; + y = 64'h3D810001FFFFFFFF; + z = 64'h00107FFFFFFEFFFE; + ans = 64'h3D71000200022001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2843767\n"); + end + x = 64'h7FF0000000000000; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2845781\n"); + end + x = 64'h405001FFFFFFFFBF; + y = 64'hC010000000000001; + z = 64'hBFE01FFFFFFFFFFB; + ans = 64'hC0700A0FFFFFFFC0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2847795\n"); + end + x = 64'hB93FFFFFFFAFFFFF; + y = 64'h03375E80771445CC; + z = 64'hC7F0200000080000; + ans = 64'hC7F0200000080000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2849809\n"); + end + x = 64'h7FF0000000000000; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2851823\n"); + end + x = 64'hFFDEEFFFFFFFFFFF; + y = 64'hFFE0000000000001; + z = 64'h4010003FBFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2853837\n"); + end + x = 64'h3FCFFFFFFFFBFFFC; + y = 64'h2CCFFFE000002000; + z = 64'hB7F6B5109C9601B2; + ans = 64'hB7F6B5109C9601B2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2855851\n"); + end + x = 64'h7FF0000000000000; + y = 64'hFFFFFFFFFFFFFFFF; + 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,"2857865\n"); + end + x = 64'hC3F57089C2360CCF; + y = 64'h0000000000000001; + z = 64'hC03FFFF001FFFFFF; + ans = 64'hC03FFFF001FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2859879\n"); + end + x = 64'hC3407FFFFFFFFFFA; + y = 64'h3FEFFFFFFFFF007F; + z = 64'hC1CEF00000000000; + ans = 64'hC34080001EEF7C3B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2861893\n"); + end + x = 64'h7FF0000000000001; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2863907\n"); + end + x = 64'hDC207FFFFDFFFFFE; + y = 64'h3CA0000000000000; + z = 64'hBFC02000007FFFFE; + ans = 64'hD8D07FFFFDFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2865921\n"); + end + x = 64'hC03FFFFFFFFFD800; + y = 64'h000FFFFFFFFFFC00; + z = 64'h43DCB39AE49E1855; + ans = 64'h43DCB39AE49E1855; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2867935\n"); + end + x = 64'h7FF0000000000001; + y = 64'h3FD0000000000001; + z = 64'hC340000000000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2869949\n"); + end + x = 64'hB056EDFAFD7AECD8; + y = 64'h3FE0000000000000; + z = 64'h46FFF80002000000; + ans = 64'h46FFF80002000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2871963\n"); + end + x = 64'hC34FFC00FFFFFFFF; + y = 64'hBEF38655F21F4B0D; + z = 64'h412FF8000000003F; + ans = 64'h425383E9C293B6B4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2873977\n"); + end + x = 64'h7FF0000000000001; + y = 64'h3FF0000000000001; + 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,"2875991\n"); + end + x = 64'hC07FFE0001FFFFFF; + y = 64'h4000000000000000; + z = 64'h4210080000007FFE; + ans = 64'h421007FFF0017FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2878005\n"); + end + x = 64'hBFDFFFE00FFFFFFF; + y = 64'h3FCCF2165E6EEA40; + z = 64'h3FF0000023FFFFFE; + ans = 64'h3FEC61C118A5CD1C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2880019\n"); + end + x = 64'h7FF0000000000001; + y = 64'h4010000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + 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,"2882033\n"); + end + x = 64'h40EAFF598CEFFAB8; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hE20FFC0000007FFE; + ans = 64'hE20FFC0000007FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2884047\n"); + end + x = 64'hC370000000007FFF; + y = 64'h433BD43E9121C012; + z = 64'hC1C48DB40A6B57F3; + ans = 64'hC6BBD43E91229EB2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2886061\n"); + end + x = 64'h7FF0000000000001; + y = 64'h7FE0000000000000; + z = 64'hBFF0000000000001; + 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,"2888075\n"); + end + x = 64'hC03F7FFFFFFFFFFD; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hC34FFFFFF9FFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2890089\n"); + end + x = 64'h40207FDFFFFFFFFF; + y = 64'h47D64227C844223E; + z = 64'hC03F7FFFFFFFFFFE; + ans = 64'h4806F40C8236B2C6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2892103\n"); + end + x = 64'h7FF0000000000001; + y = 64'h8000000000000000; + z = 64'h4340000000000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2894117\n"); + end + x = 64'hC010077FFFFFFFFE; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hC06FFE000000000E; + ans = 64'hC06FFE000000000E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2896131\n"); + end + x = 64'hC3F312D750C816D5; + y = 64'hBFBFFFD7FFFFFFFE; + z = 64'h381F7FFFFFFFFBFE; + ans = 64'h43C312BF793AF1DA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2898145\n"); + end + x = 64'h7FF0000000000001; + y = 64'h801FFFFFFFFFFFFE; + 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,"2900159\n"); + end + x = 64'hBE094AE83F023CB1; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hC02FE000001FFFFF; + ans = 64'hC02FE000001FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2902173\n"); + end + x = 64'h3F5FFFF800000FFF; + y = 64'hFFFFFFFFD7FFFFFE; + z = 64'h29F0000000001FFB; + ans = 64'hFFFFFFFFD7FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2904187\n"); + end + x = 64'h7FF0000000000001; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2906201\n"); + end + x = 64'h4000000004000000; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hBCA0000001FDFFFF; + ans = 64'hC000000004000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2908215\n"); + end + x = 64'hC3CE8C81AD84B066; + y = 64'h3E30FFFFFEFFFFFF; + z = 64'h480FFE0004000000; + ans = 64'h480FFE0004000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2910229\n"); + end + x = 64'h7FF0000000000001; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2912243\n"); + end + x = 64'hBFDEFFFFFFFF8000; + y = 64'hC000000000000001; + z = 64'h3FCCC2E7F3C48EEC; + ans = 64'h3FF3185CFE7851DE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2914257\n"); + end + x = 64'h401618D4ABC2ECBA; + y = 64'h3FE97989D3F9C41B; + z = 64'h3DEFFFFFFFFBFFEF; + ans = 64'h40119753370C7449; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2916271\n"); + end + x = 64'h7FF0000000000001; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2918285\n"); + end + x = 64'hC64000000803FFFE; + y = 64'hC340000000000001; + z = 64'h434000000FFFFDFE; + ans = 64'h499000000803FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2920299\n"); + end + x = 64'hB81FFFFFFFFFFFBA; + y = 64'hC00F001FFFFFFFFF; + z = 64'hC080000001FFF800; + ans = 64'hC080000001FFF800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2922313\n"); + end + x = 64'h7FF0000000000001; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2924327\n"); + end + x = 64'h002FFFFFEFFFFFFF; + y = 64'hFFF0000000000001; + z = 64'hFFDFFFF000000008; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2926341\n"); + end + x = 64'hFFD00000000BFFFE; + y = 64'hBFC400003FFFFFFE; + z = 64'h3FEFFFE008000000; + ans = 64'h7FA40000400EFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2928355\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2930369\n"); + end + x = 64'hC80F800000000080; + y = 64'h0010000000000000; + z = 64'h993FFFFFFFD00000; + ans = 64'h993FFFFFFFD00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2932383\n"); + end + x = 64'hBFDCE145472B2459; + y = 64'hC1DFFC3FFFFFFFFE; + z = 64'hC3FFFBFFFFFEFFFF; + ans = 64'hC3FFFBFFFFFB6443; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2934397\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h3CA0000000000001; + z = 64'hBFF0000000000001; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2936411\n"); + end + x = 64'h431FF800000000FF; + y = 64'h3FD0000000000000; + z = 64'h407FFFFFBFFFFF7F; + ans = 64'h42FFF800000020FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2938425\n"); + end + x = 64'hC7FFF0000001FFFF; + y = 64'h37F0000201FFFFFF; + z = 64'hC3DE6DD4C49D6691; + ans = 64'hC3DE6DD4C49D6691; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2940439\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h3FE0000000000001; + z = 64'h4340000000000000; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2942453\n"); + end + x = 64'h34F746586AADAF16; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'hC9BFFFFFFFFBFEFF; + ans = 64'hC9BFFFFFFFFBFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2944467\n"); + end + x = 64'hBFF00000107FFFFF; + y = 64'hC052F75C56A2DD94; + z = 64'hBFD0005FFFFFFFFF; + ans = 64'h4052E75C0A31F4CC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2946481\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h4000000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2948495\n"); + end + x = 64'hBDA01000000000FF; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h3FCFFE3FFFFFFFFF; + ans = 64'h3FCFFE3FFFEFEFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2950509\n"); + end + x = 64'hC3A0000004000001; + y = 64'hBF8EFFFEFFFFFFFE; + z = 64'h3CFFFFFFFFBFF7FF; + ans = 64'h433EFFFF07BFFFC0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2952523\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h4340000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2954537\n"); + end + x = 64'h7FEFFFFFFE00007F; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hC1FFF80000003FFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2956551\n"); + end + x = 64'hC02FF80000000002; + y = 64'h119215FB360E73AC; + z = 64'h114000200000000E; + ans = 64'h91D20975A740F010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2958565\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h7FF0000000000000; + z = 64'h3FF0000000000001; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2960579\n"); + end + x = 64'h8DEFFFFFBF7FFFFE; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hFFDFFFFFFDFF7FFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2962593\n"); + end + x = 64'h8010000007F7FFFF; + y = 64'hFFDC0FFFFFFFFFFE; + z = 64'h3FEFC00000003FFE; + ans = 64'h4005F80006FD0BFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2964607\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2966621\n"); + end + x = 64'hC020000000000240; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h3FE00003FFFFFDFE; + ans = 64'h3FE00003FFFFFDFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2968635\n"); + end + x = 64'hC030000000002200; + y = 64'hC3445F5D4A0CA2D2; + z = 64'hC01FFFDFFDFFFFFF; + ans = 64'h43845F5D4A0CCE1C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2970649\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2972663\n"); + end + x = 64'h9F900001FFFFFFFD; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hC7F0000010000040; + ans = 64'hC7F0000010000040; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2974677\n"); + end + x = 64'hFFF0000003FFFFFF; + y = 64'h00200000001FFFFF; + z = 64'h50A7FFFFFFFFFDFF; + ans = 64'hFFF8000003FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2976691\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2978705\n"); + end + x = 64'h799FF80002000000; + y = 64'hBFF0000000000001; + z = 64'hC7E5E498809D2665; + ans = 64'hF99FF80002000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2980719\n"); + end + x = 64'hDA091019619C2FB6; + y = 64'hE700000000401000; + z = 64'h3CAFFEC000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2982733\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2984747\n"); + end + x = 64'h4022E75B40B8C691; + y = 64'hC010000000000001; + z = 64'hBFD2FFED1D2049E5; + ans = 64'hC0430D5B1AF30726; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2986761\n"); + end + x = 64'h3D400000000200FE; + y = 64'hC074C153DEFA227D; + z = 64'h5290000000203FFF; + ans = 64'h5290000000203FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2988775\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2990789\n"); + end + x = 64'h7FEFFBDFFFFFFFFE; + y = 64'hFFE0000000000000; + z = 64'hA87FFFFFFFFFE07F; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2992803\n"); + end + x = 64'h40110F9BDBB44785; + y = 64'h3F8FF7FFFDFFFFFF; + z = 64'h7FEFFFFBFFFFFFF8; + ans = 64'h7FEFFFFBFFFFFFF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2994817\n"); + end + x = 64'h7FFFFFFFFFFFFFFF; + y = 64'hFFF0000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2996831\n"); + end + x = 64'h7FD03FFFFFBFFFFF; + y = 64'h0000000000000000; + z = 64'h3FFFFFFF00003FFE; + ans = 64'h3FFFFFFF00003FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"2998845\n"); + end + x = 64'h7FD116B80FD8533D; + y = 64'hC1DFFFFC0000003F; + z = 64'hB4B491B7E5F4A9B2; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3000859\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h0010000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3002873\n"); + end + x = 64'h380E83F329A88838; + y = 64'h3CA0000000000000; + z = 64'hC0000000000BFFFF; + ans = 64'hC0000000000BFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3004887\n"); + end + x = 64'h405FFFFDFFFFFFBF; + y = 64'h3EE0020008000000; + z = 64'h434000006FFFFFFF; + ans = 64'h434000006FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3006901\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h3FD0000000000001; + z = 64'h3FF0000000000001; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3008915\n"); + end + x = 64'hC047E499DDFA806A; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hB7FE0FFFFFFFFFFF; + ans = 64'hC037E499DDFA8069; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3010929\n"); + end + x = 64'h40007FFFFFE00000; + y = 64'h43E0020000000400; + z = 64'h800C91E3CE379553; + ans = 64'h43F0820FFFE00020; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3012943\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h3FF0000000000000; + z = 64'hC340000000000000; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3014957\n"); + end + x = 64'h3FBFFFFEFFFFF800; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hC340FFFFFFFFFDFF; + ans = 64'hC340FFFFFFFFFDFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3016971\n"); + end + x = 64'hA440000003E00000; + y = 64'hBF9748F93642BBE3; + z = 64'hB7F4721D96C17B0B; + ans = 64'hB7F4721D96C17B0B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3018985\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h4010000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3020999\n"); + end + x = 64'h35B10000000FFFFF; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h59B792D483A7542C; + ans = 64'h59B792D483A7542C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3023013\n"); + end + x = 64'h401080003FFFFFFF; + y = 64'h3DC0000000001FFC; + z = 64'h218FFFF80FFFFFFF; + ans = 64'h3DE08000400020FB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3025027\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h7FE0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3027041\n"); + end + x = 64'hBFCFFFFFFFFFF004; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'hF5700000000800FE; + ans = 64'hFFCFFFFFFFFFF003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3029055\n"); + end + x = 64'hBFE6CD7171563B62; + y = 64'hFFEBF7FFFFFFFFFE; + z = 64'hC34FFC00000000FF; + ans = 64'h7FE3EE0FE6CF1E65; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3031069\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3033083\n"); + end + x = 64'h400F58F62FF4033A; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h401FDFFFFFFFFDFF; + ans = 64'h401FDFFFFFFFFDFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3035097\n"); + end + x = 64'hC7FFFE0003FFFFFE; + y = 64'hC02AC90ECD6770E9; + z = 64'h3F7C001FFFFFFFFF; + ans = 64'h483AC7623FD3BC4A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3037111\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3039125\n"); + end + x = 64'hBFA01FFFFFFFFFE0; + y = 64'hBCA0000000000001; + z = 64'hC0204D08EEA95A99; + ans = 64'hC0204D08EEA95A99; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3041139\n"); + end + x = 64'h47F00000000FC000; + y = 64'h37F01FFFFFFFFDFF; + z = 64'h7FD0000040001FFF; + ans = 64'h7FD0000040001FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3043153\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3045167\n"); + end + x = 64'h400FF80000000400; + y = 64'hBFE0000000000001; + z = 64'hC3B18CA640A90418; + ans = 64'hC3B18CA640A90418; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3047181\n"); + end + x = 64'h3D2FFFFBFFFFFFFE; + y = 64'h434E000000000003; + z = 64'hBFF0000040FFFFFF; + ans = 64'h408DF7FC3FDF8001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3049195\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3051209\n"); + end + x = 64'h3FFFFFFFFF7F8000; + y = 64'hC000000000000001; + z = 64'hC0B0000800FFFFFE; + ans = 64'hC0B0040800FFEFEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3053223\n"); + end + x = 64'hC12FC00001000000; + y = 64'hC1E00002000003FE; + z = 64'hFFDFFFFFBFF7FFFF; + ans = 64'hFFDFFFFFBFF7FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3055237\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3057251\n"); + end + x = 64'h40A200000000FFFE; + y = 64'hC340000000000000; + z = 64'hBFDAE1EBBB840DBC; + ans = 64'hC3F200000000FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3059265\n"); + end + x = 64'hC1F03FFFF7FFFFFF; + y = 64'h41D0000000BFFFFF; + z = 64'hC090000001007FFF; + ans = 64'hC3D03FFFF8C2FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3061279\n"); + end + x = 64'h7FFFFFFFFFFFFFFE; + y = 64'hFFE0000000000001; + z = 64'hC340000000000000; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3063293\n"); + end + x = 64'h638FFFFFFC000FFE; + y = 64'hFFF0000000000000; + z = 64'h3FD36CFBCEB8EEED; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3065307\n"); + end + x = 64'h302FEFFFFF7FFFFF; + y = 64'h00260D4F5759FE02; + z = 64'h43F000000C000000; + ans = 64'h43F000000C000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3067321\n"); + end + x = 64'h8000000000000000; + y = 64'h0000000000000001; + 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,"3069335\n"); + end + x = 64'hC01E00000000003E; + y = 64'h0010000000000000; + z = 64'h40600001FFFFFFFF; + ans = 64'h40600001FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3071349\n"); + end + x = 64'h80200800003FFFFE; + y = 64'h3880008000004000; + z = 64'hA440083FFFFFFFFF; + ans = 64'hA440083FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3073363\n"); + end + x = 64'h8000000000000000; + y = 64'h3CA0000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3075377\n"); + end + x = 64'hC0201FF800000000; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'hC0DFFFFFFFF7C000; + ans = 64'hC0DFFFFFFFF7C000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3077391\n"); + end + x = 64'h3FBFFFFFFDFFF7FE; + y = 64'h3FEFFFFFFFFEE000; + z = 64'hBFCFFFFFF801FFFF; + ans = 64'hBFBFFFFFF2052800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3079405\n"); + end + x = 64'h8000000000000000; + y = 64'h3FE0000000000000; + 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,"3081419\n"); + end + x = 64'hB8000FFFFFFFFFFB; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'hFFF03FFFF7FFFFFE; + ans = 64'hFFF83FFFF7FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3083433\n"); + end + x = 64'hB54000000003FFFF; + y = 64'hBFD1000FFFFFFFFE; + z = 64'h3FD00000000005FF; + ans = 64'h3FD00000000005FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3085447\n"); + end + x = 64'h8000000000000000; + y = 64'h4000000000000000; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3087461\n"); + end + x = 64'hC21103FFFFFFFFFE; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hC3E0200FFFFFFFFE; + ans = 64'hC3E0201002207FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3089475\n"); + end + x = 64'hBFB00207FFFFFFFE; + y = 64'hC1F80BD9803691DC; + z = 64'hC3F000200000007E; + ans = 64'hC3F0001FFFFE7F90; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -236686,3769 +72184,9 @@ initial if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); $fwrite(fp,"3091489\n"); end - xrf = 64'h8000000000000000; - y = 64'h3F2888DBBA853F4F; - zrf = 64'h43BFFFFFFFC00008; - ans = 64'h43BFFFFFFFC00008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3092103\n"); - end - xrf = 64'h3FC000001FFBFFFF; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h3808347E56DF1CFB; - ans = 64'h3FE000001FFBFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3092717\n"); - end - xrf = 64'h8000000000000000; - y = 64'h7FFFFFFFFFFF77FF; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFF77FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3093331\n"); - end - xrf = 64'hB19FFFFFFFFFFBFE; - y = 64'hC01FFFFDFFFDFFFF; - zrf = 64'h24DFE0000000003F; - ans = 64'h31CFFFFDFFFDFBFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3093945\n"); - end - xrf = 64'h8000000000000000; - y = 64'h4010000000000000; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3094559\n"); - end - xrf = 64'hBFC08000007FFFFF; - y = 64'hC01FFF7FFFFEFFFF; - zrf = 64'hBFE0000000000000; - ans = 64'h3FE0FF7C00FEF3FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3095173\n"); - end - xrf = 64'h8000000000000000; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h41FFFFFFFFFFF7EF; - ans = 64'h41FFFFFFFFFFF7EF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3095787\n"); - end - xrf = 64'h403DB03B87843F76; - y = 64'hBF800000000FF7FF; - zrf = 64'hC1EFFFFFFFFFFFFF; - ans = 64'hC1F000000003B607; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3096401\n"); - end - xrf = 64'h43F0007F7FFFFFFE; - y = 64'h4340000000000000; - zrf = 64'h0000000000000000; - ans = 64'h4740007F7FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3097015\n"); - end - xrf = 64'h8000000000000000; - y = 64'h45500000BFFFFFFE; - zrf = 64'h4017E8D64105A119; - ans = 64'h4017E8D64105A119; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3097629\n"); - end - xrf = 64'h401FFFFFFDFFFFFF; - y = 64'h4340000000000001; - zrf = 64'hBFC01EFFFFFFFFFE; - ans = 64'h436FFFFFFE000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3098243\n"); - end - xrf = 64'h8000000000000000; - y = 64'h3FDFFC0001FFFFFF; - zrf = 64'h4010000000000000; - ans = 64'h4010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3098857\n"); - end - xrf = 64'hC1CFF7FFFFEFFFFF; - y = 64'hBDE0005FFFFFFFFF; - zrf = 64'hC7F0000000803FFF; - ans = 64'hC7F0000000803FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3099471\n"); - end - xrf = 64'h8000000000000000; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3100085\n"); - end - xrf = 64'hC030A7CF373B62D5; - y = 64'hBF4D228689037BA6; - zrf = 64'hBFD0000000000001; - ans = 64'hBFCE1ABE7C78711C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3100699\n"); - end - xrf = 64'h8000000000000000; - y = 64'h7FE0000000000001; - zrf = 64'hCC7001FDFFFFFFFF; - ans = 64'hCC7001FDFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3101313\n"); - end - xrf = 64'hC1C0FFFFFF7FFFFF; - y = 64'h40070F82E6044AF0; - zrf = 64'h3E5FFC000000001F; - ans = 64'hC1D8807B13AC1386; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3101927\n"); - end - xrf = 64'h3FBFFFDFF7FFFFFF; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3102541\n"); - end - xrf = 64'h8000000000000000; - y = 64'hC03000003FFE0000; - zrf = 64'h3FF00000000007FF; - ans = 64'h3FF00000000007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3103155\n"); - end - xrf = 64'hC80FFFFFFFDFFFF6; - y = 64'h7FF0000000000000; - zrf = 64'h802ACE332F4C4763; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3103769\n"); - end - xrf = 64'h8000000000000000; - y = 64'hB7E0000000007FFB; - zrf = 64'h4000000000000001; - ans = 64'h4000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3104383\n"); - end - xrf = 64'hC80DB237A7B2ECFA; - y = 64'h43CF7FFF00000000; - zrf = 64'hC0942C91CBC6742F; - ans = 64'hCBED3B6DDB826409; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3104997\n"); - end - xrf = 64'h8000000000000000; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'hC010000000000001; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3105611\n"); - end - xrf = 64'hBD800000FFEFFFFF; - y = 64'hBCA000000000047F; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFDFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3106225\n"); - end - xrf = 64'h8000000000000000; - y = 64'h8000000000000000; - zrf = 64'h3FF00000007FF000; - ans = 64'h3FF00000007FF000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3106839\n"); - end - xrf = 64'hC03D0F79F2E2110C; - y = 64'hC03000FFFFFFFFEF; - zrf = 64'h001E8FC2A817327E; - ans = 64'h407D114AEA813F0E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3107453\n"); - end - xrf = 64'h4010000003FFC000; - y = 64'h8000000000000001; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3108067\n"); - end - xrf = 64'h8000000000000000; - y = 64'hBFAC4EA8DFBA2E0F; - zrf = 64'h2EAFFBE000000000; - ans = 64'h2EAFFBE000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3108681\n"); - end - xrf = 64'hC1CFFDFFFC000000; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h3FBFFFFFFFDFFFBF; - ans = 64'h3FBFFFFFFFDFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3109295\n"); - end - xrf = 64'h8000000000000000; - y = 64'hEF50DFFFFFFFFFFF; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3109909\n"); - end - xrf = 64'hBFEFFF7FFC000000; - y = 64'h802C0000000007FF; - zrf = 64'hC34020C551346F33; - ans = 64'hC34020C551346F33; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3110523\n"); - end - xrf = 64'h8000000000000000; - y = 64'h8010000000000001; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3111137\n"); - end - xrf = 64'h4016D2AF65546489; - y = 64'h802FFFF00003FFFE; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h8058D2A3FBFF8C33; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3111751\n"); - end - xrf = 64'h8000000000000000; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'hBF5000001FFFFF7F; - ans = 64'hBF5000001FFFFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3112365\n"); - end - xrf = 64'hBC494CF44BE411E4; - y = 64'h40D0800FFFFFFFFF; - zrf = 64'h3F2FF0000003FFFE; - ans = 64'h3F2FEFFFFFE9E889; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3112979\n"); - end - xrf = 64'hC0B0400000010000; - y = 64'hBCA0000000000000; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3113593\n"); - end - xrf = 64'h8000000000000000; - y = 64'h43CFFFFFF803FFFF; - zrf = 64'hFFFFDFFDFFFFFFFE; - ans = 64'hFFFFDFFDFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3114207\n"); - end - xrf = 64'h43400047FFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'hBFD75FA2A3A89086; - ans = 64'hC002EC3C5475120F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3114821\n"); - end - xrf = 64'h8000000000000000; - y = 64'hB4CFFFFFFFFBFF00; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h3FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3115435\n"); - end - xrf = 64'hD64FFFFFF0080000; - y = 64'hD1DDB24D08FC815F; - zrf = 64'hC660000001000000; - ans = 64'h683DB24CFA2AC76E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3116049\n"); - end - xrf = 64'h8000000000000000; - y = 64'hBFD0000000000000; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hBFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3116663\n"); - end - xrf = 64'h000FFF000000000F; - y = 64'h3FF00800001FFFFF; - zrf = 64'h8010000000000000; - ans = 64'h000006FF801FFE0E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3117277\n"); - end - xrf = 64'h8000000000000000; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h2BAFFFFE00000400; - ans = 64'h2BAFFFFE00000400; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3117891\n"); - end - xrf = 64'h9A73CCE1CA1D11E1; - y = 64'h47EFFFFF07FFFFFF; - zrf = 64'h380E615AE8E06D92; - ans = 64'h380E615AE8E06D92; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3118505\n"); - end - xrf = 64'h43E000FFFFFFDFFF; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'hC340000000000000; - ans = 64'hC3D008FFFFFFDFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3119119\n"); - end - xrf = 64'h8000000000000000; - y = 64'hB7E4D7D8D41529FE; - zrf = 64'hC7F10000001FFFFF; - ans = 64'hC7F10000001FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3119733\n"); - end - xrf = 64'h480FFFC000000004; - y = 64'hBFE0000000000001; - zrf = 64'hFFDFE0000003FFFF; - ans = 64'hFFDFE0000003FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3120347\n"); - end - xrf = 64'h8000000000000000; - y = 64'h593FF0000FFFFFFF; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3120961\n"); - end - xrf = 64'hC06B9417C0033A6E; - y = 64'h7FD0200000002000; - zrf = 64'hC1C00000004001FF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3121575\n"); - end - xrf = 64'h8000000000000000; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hBFF0000000000000; - ans = 64'hBFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3122189\n"); - end - xrf = 64'h4760000FF7FFFFFF; - y = 64'hC020001000001FFF; - zrf = 64'h8000000000000001; - ans = 64'hC790001FF81017FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3122803\n"); - end - xrf = 64'h8000000000000000; - y = 64'hBFF0000000000001; - zrf = 64'h41EE7FFFFFFFFFFF; - ans = 64'h41EE7FFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3123417\n"); - end - xrf = 64'hB7F000000003FFFC; - y = 64'hC3EBFFFFC0000000; - zrf = 64'h4340020000007FFF; - ans = 64'h4340020000007FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3124031\n"); - end - xrf = 64'h00156990261BEC37; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'hC010000000000001; - ans = 64'hC010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3124645\n"); - end - xrf = 64'h8000000000000000; - y = 64'hB7FFFFFFFFFF03FF; - zrf = 64'hEEDF000000000200; - ans = 64'hEEDF000000000200; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3125259\n"); - end - xrf = 64'h8021FFFFFFFF7FFF; - y = 64'hC000000000000000; - zrf = 64'h41DF7FFFFFDFFFFF; - ans = 64'h41DF7FFFFFDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3125873\n"); - end - xrf = 64'h8000000000000000; - y = 64'h4013FFFFFFFFFFDF; - zrf = 64'h3FD0000000000001; - ans = 64'h3FD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3126487\n"); - end - xrf = 64'hC02FFFFFBFFFFEFF; - y = 64'h3C0EBC9683E33424; - zrf = 64'h2BCFFFFFF0000000; - ans = 64'hBC4EBC96466A0625; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3127101\n"); - end - xrf = 64'h8000000000000000; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3127715\n"); - end - xrf = 64'hC0200800000003FF; - y = 64'hC05BFA48DAC0DE8C; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3128329\n"); - end - xrf = 64'h8000000000000000; - y = 64'hC010000000000000; - zrf = 64'hBFCFE49E2BE245B9; - ans = 64'hBFCFE49E2BE245B9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3128943\n"); - end - xrf = 64'h41C000FFFFFFFEFF; - y = 64'h3FBCFA3A6B7AD55E; - zrf = 64'h3FDFFFFFFFFFE020; - ans = 64'h418CFC0A13218B3A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3129557\n"); - end - xrf = 64'h42B0000000800002; - y = 64'hC010000000000001; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC2D0000000800103; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3130171\n"); - end - xrf = 64'h8000000000000000; - y = 64'h2CFFFBFFFFFFFFF6; - zrf = 64'h3FE07FFFFFFBFFFE; - ans = 64'h3FE07FFFFFFBFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3130785\n"); - end - xrf = 64'h802000000001F7FE; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h40307FFFFFFFFFFD; - ans = 64'h40307FFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3131399\n"); - end - xrf = 64'h8000000000000000; - y = 64'h47AF7DFFFFFFFFFF; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3132013\n"); - end - xrf = 64'hBFB00000002FFFFE; - y = 64'h449FFFFFFFFEF7FE; - zrf = 64'hC07000000FF7FFFE; - ans = 64'hC4600000002F7BFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3132627\n"); - end - xrf = 64'h8000000000000000; - y = 64'hC340000000000001; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3133241\n"); - end - xrf = 64'hC3CFFFFFFE00000F; - y = 64'h401FA0393503D82D; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3133855\n"); - end - xrf = 64'h8000000000000000; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h3E9FFC0000000400; - ans = 64'h3E9FFC0000000400; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3134469\n"); - end - xrf = 64'h41CFFFF3FFFFFFFE; - y = 64'h37F19D07D7E0590A; - zrf = 64'hBCAFFFFFFC00FFFF; - ans = 64'hBCAFFFFFFC00FF72; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3135083\n"); - end - xrf = 64'h3F6FFFFFFF003FFE; - y = 64'hFFE0000000000000; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hFF5FFFFFFF003FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3135697\n"); - end - xrf = 64'h8000000000000000; - y = 64'h43400001FFFFF7FE; - zrf = 64'h43E002FFFFFFFFFF; - ans = 64'h43E002FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3136311\n"); - end - xrf = 64'hC1F6144314164BCD; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h40F003FFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3136925\n"); - end - xrf = 64'h8000000000000000; - y = 64'hC019164BC4066991; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h001FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3137539\n"); - end - xrf = 64'hB8000000010003FF; - y = 64'hC0F46B4BFE151F0B; - zrf = 64'h38000000001BFFFF; - ans = 64'h39046B5BFF5BD900; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3138153\n"); - end - xrf = 64'h8000000000000000; - y = 64'hFFF0000000000000; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hFFF8000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3138767\n"); - end - xrf = 64'hC2900000001FFEFE; - y = 64'hC065A4DA1815F209; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3139381\n"); - end - xrf = 64'h8000000000000000; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hA90FFFF000000080; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3139995\n"); - end - xrf = 64'h434FFFFFFDFFFFF7; - y = 64'h43DFFFFC00001FFF; - zrf = 64'hBAB00003FFDFFFFF; - ans = 64'h473FFFFBFE002036; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3140609\n"); - end - xrf = 64'hCFFFFFFFFFFFFFFF; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'hBFF0000000000000; + x = 64'h8000000000000000; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -240463,19 +72201,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -240491,2080 +72229,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3141223\n"); + $fwrite(fp,"3093503\n"); end - xrf = 64'h8000000000000001; - y = 64'h3F90080000000000; - zrf = 64'hC1F000001FFFFFE0; - ans = 64'hC1F000001FFFFFE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3141837\n"); - end - xrf = 64'hC7E0000040000FFE; - y = 64'h0000000000000001; - zrf = 64'h37E0000000000011; - ans = 64'h37E0000000000011; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3142451\n"); - end - xrf = 64'h8000000000000001; - y = 64'h400EFFFFFF000000; - zrf = 64'h0010000000000000; - ans = 64'h000FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3143065\n"); - end - xrf = 64'h43EDDFB09753FFA6; - y = 64'h37AFFFF003FFFFFF; - zrf = 64'h3FF1C45D282E7E53; - ans = 64'h3FF1C45D282E7E53; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3143679\n"); - end - xrf = 64'h8000000000000001; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hBCA0000000000000; - ans = 64'hBCA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3144293\n"); - end - xrf = 64'hBFD00003FFFFFFEF; - y = 64'hBFDACEDC26695437; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3144907\n"); - end - xrf = 64'h8000000000000001; - y = 64'h0010000000000001; - zrf = 64'hC1C1DFFFFFFFFFFF; - ans = 64'hC1C1DFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3145521\n"); - end - xrf = 64'h4040000000000801; - y = 64'hC7800007FFFFFFEF; - zrf = 64'hC04FFFFFFFFBFFEF; - ans = 64'hC7D00008000007F0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3146135\n"); - end - xrf = 64'hC35FFFFD7FFFFFFE; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3146749\n"); - end - xrf = 64'h8000000000000001; - y = 64'h3FDFFFFE007FFFFF; - zrf = 64'h3940C6BA3B0B3184; - ans = 64'h3940C6BA3B0B3184; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3147363\n"); - end - xrf = 64'h7FFFF00000000000; - y = 64'h3CA0000000000000; - zrf = 64'hBBA00000000EFFFF; - ans = 64'h7FFFF00000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3147977\n"); - end - xrf = 64'h8000000000000001; - y = 64'h40211275FFE5EE3C; - zrf = 64'h0000000000000001; - ans = 64'h8000000000000008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3148591\n"); - end - xrf = 64'hC0C00000013FFFFE; - y = 64'h4067902331AAF6C5; - zrf = 64'h380FFFFFFFE00000; - ans = 64'hC137902333823982; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3149205\n"); - end - xrf = 64'h8000000000000001; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h8010000000000001; - ans = 64'h8010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3149819\n"); - end - xrf = 64'hC050000000010000; - y = 64'hBF1003FFFFF7FFFE; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h402002007FFFFF20; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3150433\n"); - end - xrf = 64'h8000000000000001; - y = 64'h3FD0000000000000; - zrf = 64'h3FDFFFFFFBF80000; - ans = 64'h3FDFFFFFFBF80000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3151047\n"); - end - xrf = 64'h41A2FFFFFFFFFFFF; - y = 64'hC01F4C181CF9031A; - zrf = 64'h59EAEF43B21B025D; - ans = 64'h59EAEF43B21B025D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3151661\n"); - end - xrf = 64'h2F4FFFFFFFBFFF7F; - y = 64'h3FD0000000000001; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3152275\n"); - end - xrf = 64'h8000000000000001; - y = 64'hC1C01FFFFFFFFEFE; - zrf = 64'h03100007FE000000; - ans = 64'h03100007FE000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3152889\n"); - end - xrf = 64'h41D0000100000800; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h37000000000FFEFF; - ans = 64'h41C00001000007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3153503\n"); - end - xrf = 64'h8000000000000001; - y = 64'hBFD00000003FFFFF; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3154117\n"); - end - xrf = 64'h3FCFFFFDFFFFFFFE; - y = 64'hB5A72C97AC0E810C; - zrf = 64'hC3D000000040001F; - ans = 64'hC3D000000040001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3154731\n"); - end - xrf = 64'h8000000000000001; - y = 64'h3FE0000000000001; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h8010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3155345\n"); - end - xrf = 64'h3E1E236829225737; - y = 64'hB7E405088A99DC41; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3155959\n"); - end - xrf = 64'h8000000000000001; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h3CAFFFFC003FFFFF; - ans = 64'h3CAFFFFC003FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3156573\n"); - end - xrf = 64'h9EAF803FFFFFFFFF; - y = 64'h985FFFFC000007FF; - zrf = 64'hBFBFFE007FFFFFFE; - ans = 64'hBFBFFE007FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3157187\n"); - end - xrf = 64'h3FDFFFFFE03FFFFF; - y = 64'h3FF0000000000000; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'h3FDFFFFFE03FFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3157801\n"); - end - xrf = 64'h8000000000000001; - y = 64'h3817CB84DBC4B68E; - zrf = 64'hC03F153C7B568390; - ans = 64'hC03F153C7B568390; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3158415\n"); - end - xrf = 64'h41CFFFFFFFFFDFDE; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h3FBFFDFFFF000000; - ans = 64'h41E000000003EFAE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3159029\n"); - end - xrf = 64'h8000000000000001; - y = 64'hC03FFFFFFFFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3159643\n"); - end - xrf = 64'h41CA0E88599F6184; - y = 64'hC34FFFFF801FFFFE; - zrf = 64'h43D000400FFFFFFF; - ans = 64'hC52A0E87717D4E24; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3160257\n"); - end - xrf = 64'h8000000000000001; - y = 64'h4000000000000000; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3160871\n"); - end - xrf = 64'h41CFFFFFFFFFEFF0; - y = 64'hC02FFBFFFFFFF7FF; - zrf = 64'h4000000000000000; - ans = 64'hC20FFBFFFFEFE7F1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3161485\n"); - end - xrf = 64'h8000000000000001; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h3FD0800002000000; - ans = 64'h3FD0800002000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3162099\n"); - end - xrf = 64'hC07000000000005E; - y = 64'h3F20000000103FFF; - zrf = 64'hC1D07FFF7FFFFFFF; - ans = 64'hC1D07FFF8001FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3162713\n"); - end - xrf = 64'hBFC01FFFFFFFFE00; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hBCA0000000000000; - ans = 64'hBFE01FFFFFFFFE00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3163327\n"); - end - xrf = 64'h8000000000000001; - y = 64'hBEE0000807FFFFFE; - zrf = 64'hD47000001E000000; - ans = 64'hD47000001E000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3163941\n"); - end - xrf = 64'hB81DAD3FB1C8BFCB; - y = 64'h4010000000000001; - zrf = 64'hC03FFE0FFFFFFFFE; - ans = 64'hC03FFE0FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3164555\n"); - end - xrf = 64'h8000000000000001; - y = 64'hC15FFBFFFFFFFBFF; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3165169\n"); - end - xrf = 64'h400C05A976082539; - y = 64'h3B20008007FFFFFF; - zrf = 64'h4000200000200000; - ans = 64'h4000200000200000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3165783\n"); - end - xrf = 64'h8000000000000001; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3166397\n"); - end - xrf = 64'h43EF3C4FB6317308; - y = 64'h401FA877217B4DCA; - zrf = 64'h3FF0000000000001; - ans = 64'h441EE6DE23F36688; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3167011\n"); - end - xrf = 64'h8000000000000001; - y = 64'h4340000000000001; - zrf = 64'h43FFFFFFFFFFFDF7; - ans = 64'h43FFFFFFFFFFFDF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3167625\n"); - end - xrf = 64'h381B8A7CEA43CD38; - y = 64'hBCA00000000000FE; - zrf = 64'hBFCFF7FFFFFFFBFF; - ans = 64'hBFCFF7FFFFFFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3168239\n"); - end - xrf = 64'h3FC0003000000000; + x = 64'h381FFFFFFFBFFFFD; y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h8010000000000001; - ans = 64'h4320002FFFFFFFFF; + z = 64'h3FC13FC964804937; + ans = 64'h3FC13FC964804937; rn = 1; rz = 0; rm = 0; @@ -242578,19 +72248,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -242606,12 +72276,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3168853\n"); + $fwrite(fp,"3095517\n"); end - xrf = 64'h8000000000000001; - y = 64'hC1C8000007FFFFFE; - zrf = 64'hC3CC26562E83F4EA; - ans = 64'hC3CC26562E83F4EA; + x = 64'hBAE49B6CCC5D9A1D; + y = 64'hC00FFFFFFFFFFF40; + z = 64'h000FFFFFFFFFFFED; + ans = 64'h3B049B6CCC5D99A1; rn = 1; rz = 0; rm = 0; @@ -242625,19 +72295,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -242653,247 +72323,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3169467\n"); + $fwrite(fp,"3097531\n"); end - xrf = 64'hC0039AA7F4BDCC1A; - y = 64'h7FE0000000000000; - zrf = 64'h2EFFFFFFFF0003FF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3170081\n"); - end - xrf = 64'h8000000000000001; - y = 64'h7FEF848CC01517B4; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3170695\n"); - end - xrf = 64'h43CFFC0000000020; - y = 64'h4EF11317FB120971; - zrf = 64'h32A0000003BFFFFF; - ans = 64'h52D110F59812A741; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3171309\n"); - end - xrf = 64'h8000000000000001; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3171923\n"); - end - xrf = 64'hBE3FFFC1FFFFFFFE; - y = 64'h1500000000080008; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3172537\n"); - end - xrf = 64'h8000000000000001; + x = 64'h8000000000000000; y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h410FFFFFFC007FFE; - ans = 64'h410FFFFFFC007FFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -242907,19 +72342,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -242935,12 +72370,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3173151\n"); + $fwrite(fp,"3099545\n"); end - xrf = 64'h7FFE07FFFFFFFFFF; - y = 64'h40FFFF3FFFFFFFFE; - zrf = 64'h47700F8000000000; - ans = 64'h7FFE07FFFFFFFFFF; + x = 64'hFFE0044000000000; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h7FD0000020000000; + ans = 64'h7FFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -242954,19 +72389,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -242982,12 +72417,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3173765\n"); + $fwrite(fp,"3101559\n"); end - xrf = 64'hBFDFFFFFBFFFF7FF; - y = 64'h7FF0000000000001; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h7FF8000000000001; + x = 64'hE31FFFF7FFFC0000; + y = 64'hBFE0003FFFFFFFFF; + z = 64'h41C000000000001F; + ans = 64'h6310003BFFEDFFF7; rn = 1; rz = 0; rm = 0; @@ -243001,19 +72436,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -243029,2314 +72464,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3174379\n"); + $fwrite(fp,"3103573\n"); end - xrf = 64'h8000000000000001; - y = 64'hA2600000080000FF; - zrf = 64'hBCEB98ACD7FD8CA0; - ans = 64'hBCEB98ACD7FD8CA0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3174993\n"); - end - xrf = 64'hFFD0000000380000; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h3F61000000100000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3175607\n"); - end - xrf = 64'h8000000000000001; - y = 64'hBFE00007FFFEFFFF; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3176221\n"); - end - xrf = 64'h801FFFF000002000; - y = 64'h3E4000007FBFFFFF; - zrf = 64'hFFEFFFBFBFFFFFFE; - ans = 64'hFFEFFFBFBFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3176835\n"); - end - xrf = 64'h8000000000000001; - y = 64'h8000000000000001; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3177449\n"); - end - xrf = 64'hCA1FFFFFBFEFFFFF; - y = 64'h40104000000000FE; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'hCA403FFFDF77E0FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3178063\n"); - end - xrf = 64'h8000000000000001; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h50BFFFFF80000007; - ans = 64'h50BFFFFF80000007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3178677\n"); - end - xrf = 64'hC1F0010000001FFF; - y = 64'h4682F7C4BE71CF6A; - zrf = 64'h801FBC2C44B340E6; - ans = 64'hC882F8F43ABDDC75; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3179291\n"); - end - xrf = 64'h3FF000000080007F; - y = 64'h8010000000000000; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3179905\n"); - end - xrf = 64'h8000000000000001; - y = 64'h3F810000003FFFFE; - zrf = 64'h3FF7FFFFFFFFFFEF; - ans = 64'h3FF7FFFFFFFFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3180519\n"); - end - xrf = 64'hBFB0009FFFFFFFFF; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h47E14C1A2DD3B4B1; - ans = 64'h47E14C1A2DD3B4B1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3181133\n"); - end - xrf = 64'h8000000000000001; - y = 64'hB7F000000000003E; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3181747\n"); - end - xrf = 64'hC9AFFFFFFEEFFFFF; - y = 64'hC030000001FFFFF6; - zrf = 64'h400000400000007F; - ans = 64'h49F000000177FFF5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3182361\n"); - end - xrf = 64'h8000000000000001; - y = 64'hBCA0000000000000; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h401FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3182975\n"); - end - xrf = 64'h37E0010400000000; - y = 64'hB60E000040000000; - zrf = 64'h3FD0000000000000; - ans = 64'h3FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3183589\n"); - end - xrf = 64'h8000000000000001; - y = 64'hBCA0000000000001; - zrf = 64'h3FFEFFFFFFFFFFFD; - ans = 64'h3FFEFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3184203\n"); - end - xrf = 64'hC051984EB254C405; - y = 64'h380FFFFFFFFFFFBD; - zrf = 64'hBFDFFFFEFFFE0000; - ans = 64'hBFDFFFFEFFFE0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3184817\n"); - end - xrf = 64'hDFF000000001FFC0; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3185431\n"); - end - xrf = 64'h8000000000000001; - y = 64'h403FFFFAFFFFFFFF; - zrf = 64'h3FBFFFFF0000FFFE; - ans = 64'h3FBFFFFF0000FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3186045\n"); - end - xrf = 64'h3FD00000040000FF; - y = 64'hBFD0000000000001; - zrf = 64'h3B9FFFFEFFFFFFFD; - ans = 64'hBFB0000004000100; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3186659\n"); - end - xrf = 64'h8000000000000001; - y = 64'h585F840000000000; - zrf = 64'hC000000000000000; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3187273\n"); - end - xrf = 64'h3FE010003FFFFFFF; - y = 64'h3FDCF4E15823EAC4; - zrf = 64'h40D002000000001F; - ans = 64'h40D0020E88EB56C7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3187887\n"); - end - xrf = 64'h8000000000000001; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h4010000000000000; - ans = 64'h4010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3188501\n"); - end - xrf = 64'h3FFFFFFFFFC02000; - y = 64'h3FEE000020000000; - zrf = 64'h3CA0000000000001; - ans = 64'h3FFE00001FC41E00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3189115\n"); - end - xrf = 64'h8000000000000001; - y = 64'hBFE0000000000000; - zrf = 64'hCF2FFFFF00080000; - ans = 64'hCF2FFFFF00080000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3189729\n"); - end - xrf = 64'hBFCE0B425BCBFB74; - y = 64'hC060000000047FFF; - zrf = 64'h43D0008000007FFF; - ans = 64'h43D0008000007FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3190343\n"); - end - xrf = 64'h480FC00000000006; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3190957\n"); - end - xrf = 64'h8000000000000001; - y = 64'h47F1710E4E562E96; - zrf = 64'hBD4FFFFFF7FFDFFF; - ans = 64'hBD4FFFFFF7FFDFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3191571\n"); - end - xrf = 64'h986A47CFEF9354B1; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hC1FDFFFFFFFFDFFF; - ans = 64'hC1FDFFFFFFFFDFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3192185\n"); - end - xrf = 64'h8000000000000001; - y = 64'h7FFC6AF03F2EE520; - zrf = 64'hBFF0000000000001; - ans = 64'h7FFC6AF03F2EE520; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3192799\n"); - end - xrf = 64'h41D0FFFFFFF00000; - y = 64'hC670400000000010; - zrf = 64'h802A369C60C3660A; - ans = 64'hC85143FFFFEFC011; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3193413\n"); - end - xrf = 64'h8000000000000001; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h4000000000000001; - ans = 64'h4000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3194027\n"); - end - xrf = 64'hA89FF00000002000; - y = 64'hC3CF7FFFEFFFFFFF; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h2C7F703FF0081F7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3194641\n"); - end - xrf = 64'h8000000000000001; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h002E000000100000; - ans = 64'h002E000000100001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3195255\n"); - end - xrf = 64'hFBACD419571A8A67; - y = 64'hBFB000000007FFF6; - zrf = 64'hCCFFFFFFFFEBFFFF; - ans = 64'h7B6CD4195728F462; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3195869\n"); - end - xrf = 64'h402FFFFFEFFFFFFE; - y = 64'hC000000000000001; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFFFFFFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3196483\n"); - end - xrf = 64'h8000000000000001; - y = 64'h41AAD58B6045CD6B; - zrf = 64'hC10A304B72BC6F6B; - ans = 64'hC10A304B72BC6F6B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3197097\n"); - end - xrf = 64'h37FA903A0F051747; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h1580001FFFFFFFFA; - ans = 64'hB81A903A0F051746; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3197711\n"); - end - xrf = 64'h8000000000000001; - y = 64'hBD7000FFFFFFFFFF; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3198325\n"); - end - xrf = 64'h409FFFFFFE007FFF; - y = 64'hBFF0000800001FFE; - zrf = 64'hC03FFF7EFFFFFFFF; - ans = 64'hC0A04006FD005F7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3198939\n"); - end - xrf = 64'h8000000000000001; - y = 64'hC010000000000001; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3199553\n"); - end - xrf = 64'hB7FFFFFFFFFFFFF6; - y = 64'h3F9FFFFFEFFFFFFB; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'hB7AFFFFFEFFFFFF1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3200167\n"); - end - xrf = 64'h8000000000000001; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h30E0007FF8000000; - ans = 64'h30E0007FF8000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3200781\n"); - end - xrf = 64'h2403E22FEBFF5C8C; - y = 64'hA2700000001FF000; - zrf = 64'hFFF2D8FC1EB17C85; - ans = 64'hFFFAD8FC1EB17C85; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3201395\n"); - end - xrf = 64'h439080FFFFFFFFFE; - y = 64'hC340000000000000; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'hC6E080FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3202009\n"); - end - xrf = 64'h8000000000000001; - y = 64'h4007FFFFDFFFFFFF; - zrf = 64'hC800000003FFFFFF; - ans = 64'hC800000003FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3202623\n"); - end - xrf = 64'h7FEFBFEFFFFFFFFF; - y = 64'hC340000000000001; - zrf = 64'hBF32430CFD082394; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3203237\n"); - end - xrf = 64'h8000000000000001; - y = 64'hBFCDCBE729492DEC; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3203851\n"); - end - xrf = 64'hB97FFFFFFFFFF80F; - y = 64'hBE3FFFFFFFFFFFFF; - zrf = 64'h43F0001FFFEFFFFF; - ans = 64'h43F0001FFFEFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3204465\n"); - end - xrf = 64'h8000000000000001; - y = 64'hFFE0000000000000; - zrf = 64'h3FEFFFFFFFFFFFFE; + x = 64'h8000000000000000; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h3FF0000000000001; ans = 64'h3FF0000000000001; rn = 1; rz = 0; @@ -245351,19 +72483,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -245379,12 +72511,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3205079\n"); + $fwrite(fp,"3105587\n"); end - xrf = 64'h43D1A8D2E24A2428; - y = 64'hC3DFFFE000000020; - zrf = 64'h0000000000000000; - ans = 64'hC7C1A8C1397741F0; + x = 64'h4BF0082000000000; + y = 64'h8010000000000001; + z = 64'h405E040000000000; + ans = 64'h405E040000000000; rn = 1; rz = 0; rm = 0; @@ -245398,19 +72530,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -245426,12 +72558,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3205693\n"); + $fwrite(fp,"3107601\n"); end - xrf = 64'h8000000000000001; - y = 64'hFFE0000000000001; - zrf = 64'hC1FFBFFFDFFFFFFE; - ans = 64'hC1FFBFFFDFFFFFFE; + x = 64'hD1FFFFFFFF9FFFFF; + y = 64'hFFF0040000010000; + z = 64'h3DBFFFFFFF7FFF7F; + ans = 64'hFFF8040000010000; rn = 1; rz = 0; rm = 0; @@ -245445,19 +72577,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -245473,12 +72605,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3206307\n"); + $fwrite(fp,"3109615\n"); end - xrf = 64'hB76008000FFFFFFF; - y = 64'h41F000000000080F; - zrf = 64'hC1E5F2F67AF51AB8; - ans = 64'hC1E5F2F67AF51AB8; + x = 64'h8000000000000000; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; rn = 1; rz = 0; rm = 0; @@ -245492,19 +72624,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -245520,12 +72652,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3206921\n"); + $fwrite(fp,"3111629\n"); end - xrf = 64'hEB6FFFF9FFFFFFFE; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h4010000000000000; - ans = 64'h7FF0000000000000; + x = 64'h406FFE0000FFFFFE; + y = 64'hBFD0000000000001; + z = 64'h400F499C83E9329A; + ans = 64'hC04E096638C16CD6; rn = 1; rz = 0; rm = 0; @@ -245539,19 +72671,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -245567,12 +72699,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3207535\n"); + $fwrite(fp,"3113643\n"); end - xrf = 64'h8000000000000001; - y = 64'h43DFC007FFFFFFFE; - zrf = 64'h08BFFEFFC0000000; - ans = 64'h08BFFEFFC0000000; + x = 64'hBF4000401FFFFFFF; + y = 64'h37043FFFFFFFFFFF; + z = 64'h43E22053F97A12DC; + ans = 64'h43E22053F97A12DC; rn = 1; rz = 0; rm = 0; @@ -245586,19 +72718,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -245614,12 +72746,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3208149\n"); + $fwrite(fp,"3115657\n"); end - xrf = 64'hC1FFFFFFE0000400; - y = 64'hFFF0000000000000; - zrf = 64'h3FF00003C0000000; - ans = 64'h7FF0000000000000; + x = 64'h8000000000000000; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -245633,19 +72765,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -245661,12 +72793,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3208763\n"); + $fwrite(fp,"3117671\n"); end - xrf = 64'h8000000000000001; - y = 64'hBFDFFFFFF0003FFE; - zrf = 64'hBFD0000000000000; - ans = 64'hBFD0000000000000; + x = 64'hC05FFFFFFFDEFFFF; + y = 64'hBFF0000000000001; + z = 64'hC01000000007DFFF; + ans = 64'h405EFFFFFFDE8201; rn = 1; rz = 0; rm = 0; @@ -245680,19 +72812,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -245708,12 +72840,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3209377\n"); + $fwrite(fp,"3119685\n"); end - xrf = 64'h6D4BFFFFFFFFFBFF; - y = 64'h3FB000007FE00000; - zrf = 64'hBFD1FFFFFFFFFFFF; - ans = 64'h6D0C0000DFC7FBFF; + x = 64'h400040000007FFFF; + y = 64'hBFA738FE57513611; + z = 64'hC0200000000081FF; + ans = 64'hC0202F2BC4A1F62E; rn = 1; rz = 0; rm = 0; @@ -245727,19 +72859,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -245755,857 +72887,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3209991\n"); + $fwrite(fp,"3121699\n"); end - xrf = 64'h8000000000000001; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h3FE0000000000000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3210605\n"); - end - xrf = 64'hC291007FFFFFFFFF; - y = 64'hBF200114E0E1C872; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3211219\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h0000000000000000; - zrf = 64'hC1DFFFFFFFF7FFFB; - ans = 64'hC1DFFFFFFFF7FFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3211833\n"); - end - xrf = 64'hBFF410E3E7C9D4AF; - y = 64'hB98000003FFFBFFE; - zrf = 64'h3FEFFFFFFFF80080; - ans = 64'h3FEFFFFFFFF80080; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3212447\n"); - end - xrf = 64'h3FAC000000000020; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h4000000000000001; - ans = 64'h4000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3213061\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h801FFFE800000000; - zrf = 64'hC3CFFFFFFE000010; - ans = 64'hC3CFFFFFFE000010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3213675\n"); - end - xrf = 64'h39D062BBD0CEA065; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h55F10AD99CB7744A; - ans = 64'h55F10AD99CB7744A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3214289\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h3816EC8373D1D7C4; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3214903\n"); - end - xrf = 64'h37EFFFFFFF7FFF7F; - y = 64'hC0AFFFFFFFFC0020; - zrf = 64'hCF5FFF0000000007; - ans = 64'hCF5FFF0000000007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3215517\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h3FD0000000000001; - ans = 64'h3FD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3216131\n"); - end - xrf = 64'hBFC8A99A7068420A; - y = 64'hC63FFFFEFFBFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3216745\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h409FFFDFFFFFFEFF; - ans = 64'h409FFFDFFFFFFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3217359\n"); - end - xrf = 64'hB30F00000000007F; - y = 64'hC03FFFFFFFFFFFF3; - zrf = 64'hBFF0010000400000; - ans = 64'hBFF0010000400000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3217973\n"); - end - xrf = 64'h41D3FFFFFFFFFFFC; - y = 64'h3CA0000000000001; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h4000000013FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3218587\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'hC02704BE5CEB7478; - zrf = 64'h47F0000FFFFFFFDF; - ans = 64'h47F0000FFFFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3219201\n"); - end - xrf = 64'hC01D83A25A3526E3; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hC80FFFFFBFFFFFF7; - ans = 64'hC80FFFFFBFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3219815\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'hBF903FEFFFFFFFFF; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h801FBF003FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3220429\n"); - end - xrf = 64'h40800005FFFFFFFF; - y = 64'h3FBFFFFF5FFFFFFF; - zrf = 64'hC46FFFFFFFF87FFE; - ans = 64'hC46FFFFFFFF87FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3221043\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h3FD0000000000001; - zrf = 64'h3CAFFFFFFFFFFFFF; + x = 64'h8000000000000000; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; ans = 64'h3CAFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -246620,19 +72906,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -246648,12 +72934,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3221657\n"); + $fwrite(fp,"3123713\n"); end - xrf = 64'h002FFFF00003FFFF; - y = 64'hBCEFFFFFFF6FFFFE; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; + x = 64'hBF2000FEFFFFFFFE; + y = 64'hC010000000000000; + z = 64'hC7F5A230266AE7A3; + ans = 64'hC7F5A230266AE7A3; rn = 1; rz = 0; rm = 0; @@ -246667,19 +72953,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -246695,12 +72981,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3222271\n"); + $fwrite(fp,"3125727\n"); end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hBF30040003FFFFFF; - ans = 64'hBF30040003FFFFFF; + x = 64'h43DFFFFFFFFFFFF4; + y = 64'h3FCFEFE000000000; + z = 64'h306FFFFFFFFE4000; + ans = 64'h43BFEFDFFFFFFFF4; rn = 1; rz = 0; rm = 0; @@ -246714,19 +73000,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -246742,4523 +73028,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3222885\n"); + $fwrite(fp,"3127741\n"); end - xrf = 64'hBE402FFFFFFFFFFF; - y = 64'h4DC0000FF7FFFFFE; - zrf = 64'h480FB7FFFFFFFFFE; - ans = 64'hCC10301027E7FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3223499\n"); - end - xrf = 64'h66B0000020003FFE; - y = 64'h3FE0000000000000; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h66A0000020003FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3224113\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'hC3FF800000000006; - zrf = 64'h582FFFF001000000; - ans = 64'h582FFFF001000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3224727\n"); - end - xrf = 64'h41F1FBFFFFFFFFFE; - y = 64'h3FE0000000000001; - zrf = 64'hBAAFC00000000800; - ans = 64'h41E1FBFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3225341\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'hC9E000000FFFEFFF; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h0A0000000FFFEFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3225955\n"); - end - xrf = 64'h3FC4D5E06C217663; - y = 64'h3FEFFFFBFFFEFFFF; - zrf = 64'hBFE26C4F295F227E; - ans = 64'hBFDA6DAF6A0BE3E4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3226569\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h3FF0000000000000; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h000FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3227183\n"); - end - xrf = 64'hC03FFFFFFFE7FFFE; - y = 64'h41EF800000020000; - zrf = 64'hC340000000000000; - ans = 64'hC340000FBFFFFFF5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3227797\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h3FF0000000000001; - zrf = 64'h3F6FF3FFFFFFFFFF; - ans = 64'h3F6FF3FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3228411\n"); - end - xrf = 64'h800FFFFFFFDDFFFF; - y = 64'hC7EFFFDFFFFF7FFF; - zrf = 64'hC0381267393B2AC0; - ans = 64'hC0381267393B2AC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3229025\n"); - end - xrf = 64'hC3C28B314BB3DDF5; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h3FE0000000000000; - ans = 64'hC3D28B314BB3DDF4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3229639\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'hC00000007FFFDFFF; - zrf = 64'hBFCFBFFBFFFFFFFE; - ans = 64'hBFCFBFFBFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3230253\n"); - end - xrf = 64'hC1DFFFDFFFE00000; - y = 64'h4000000000000000; - zrf = 64'hBFE6B54C63D18D14; - ans = 64'hC1EFFFDFFFF6B54C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3230867\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'hC0E0000400FFFFFE; - zrf = 64'h8000000000000000; - ans = 64'h0100000400FFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3231481\n"); - end - xrf = 64'hC020000000021FFF; - y = 64'h381000000005FFFE; - zrf = 64'h403FFF8001FFFFFF; - ans = 64'h403FFF8001FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3232095\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h0010000000000000; - ans = 64'h8027FFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3232709\n"); - end - xrf = 64'h1DCC4CEF5FBE077C; - y = 64'hC19F001FFFFFFFFE; - zrf = 64'hC010000000000001; - ans = 64'hC010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3233323\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h4010000000000000; - zrf = 64'hC3F0000000200100; - ans = 64'hC3F0000000200100; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3233937\n"); - end - xrf = 64'h0020000200000000; - y = 64'h3FF001FFFFFFFF7F; - zrf = 64'h418FAFFFFFFFFFFE; - ans = 64'h418FAFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3234551\n"); - end - xrf = 64'h6B1FFFFFFFFFFF87; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h3FD0000000000001; - ans = 64'h6B4FFFFFFFFFFF86; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3235165\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'hBE201FBFFFFFFFFE; - zrf = 64'h43399FFC4505CB9F; - ans = 64'h43399FFC4505CB9F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3235779\n"); - end - xrf = 64'hC7F000001FFFFDFF; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hBCA008000003FFFE; - ans = 64'hC82000001FFFFDFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3236393\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h40E02F860C526F0C; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3237007\n"); - end - xrf = 64'h3FD000000000040F; - y = 64'hC02BC23F1AA21C79; - zrf = 64'hC3030C02BE2724D5; - ans = 64'hC3030C02BE2724F1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3237621\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h0000000000000001; - ans = 64'h836FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3238235\n"); - end - xrf = 64'hBFC9124AC36DEE47; - y = 64'hC40DC17423A58077; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'h43E7502512430022; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3238849\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h067FFFFF00000000; - ans = 64'h067FFFFEFFFFFFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3239463\n"); - end - xrf = 64'hBF900001FFFFE000; - y = 64'hBFCCDA9EA48F1915; - zrf = 64'hC06FEFFFFFFFEFFF; - ans = 64'hC06FEFE3255DB01C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3240077\n"); - end - xrf = 64'hCAAF062EF62EA325; - y = 64'h7FE0000000000001; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3240691\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h401FFF800001FFFF; - zrf = 64'h4003C8CC6DA57FC4; - ans = 64'h4003C8CC6DA57FC4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3241305\n"); - end - xrf = 64'hC360000002040000; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h3ECFFFFFFDFFFF7F; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3241919\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h3FD1000000FFFFFF; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3242533\n"); - end - xrf = 64'hB81FFFFFFF7FFDFF; - y = 64'hC01F77FFFFFFFFFF; - zrf = 64'h4181B4443EED7538; - ans = 64'h4181B4443EED7538; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3243147\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h7FF0000000000000; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3243761\n"); - end - xrf = 64'h3D9502F76012BACF; - y = 64'h3FC19288FA52ABC7; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hBFFFFFFFFFFFF474; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3244375\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h4006369F85AFF3DB; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3244989\n"); - end - xrf = 64'h43500000000007DF; - y = 64'h3E7F800004000000; - zrf = 64'h271FFFFFFFFFFFFF; - ans = 64'h41DF800004000F7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3245603\n"); - end - xrf = 64'h400FFFEF00000000; - y = 64'h8000000000000000; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h001FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3246217\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h38136AC1C6F3DA6D; - zrf = 64'hC3D0000000000000; - ans = 64'hC3D0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3246831\n"); - end - xrf = 64'hC0AF0000FFFFFFFE; - y = 64'h8000000000000001; - zrf = 64'hCBBF9EF686B069CF; - ans = 64'hCBBF9EF686B069CF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3247445\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h41C003FFFFFBFFFF; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3248059\n"); - end - xrf = 64'hBFDD4485F626299F; - y = 64'hBFC0000000100FFF; - zrf = 64'h2C203FFFDFFFFFFF; - ans = 64'h3FAD4485F6438B68; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3248673\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3249287\n"); - end - xrf = 64'h001FFFFFF7FFFFEE; - y = 64'hC01DFFFFFFFFFFFD; - zrf = 64'hBFF0000000000000; - ans = 64'hBFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3249901\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h8010000000000001; - zrf = 64'hC0632F971E01269A; - ans = 64'hC0632F971E01269A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3250515\n"); - end - xrf = 64'hC070000008000800; - y = 64'hC3F5AE6BDDD0E4AC; - zrf = 64'hBFBA87175AC889D8; - ans = 64'h4475AE6BE8A82572; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3251129\n"); - end - xrf = 64'hAC6158E30C284003; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h0010000000000000; - ans = 64'h0010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3251743\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h3FE1A16DB80FAC6F; - zrf = 64'h47FE44C8F9A9F8E7; - ans = 64'h47FE44C8F9A9F8E7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3252357\n"); - end - xrf = 64'hC0F2000000004000; - y = 64'hBCA0000000000000; - zrf = 64'h38100007E0000000; - ans = 64'h3DA2000000004000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3252971\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h4710200000200000; - zrf = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3253585\n"); - end - xrf = 64'hC2C2003FFFFFFFFF; - y = 64'h43F003FFFFFFFDFF; - zrf = 64'h47EFFC0000000000; - ans = 64'h47EFFBFB7ECFFC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3254199\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3254813\n"); - end - xrf = 64'hC1D000000003FFFE; - y = 64'hC03000FF7FFFFFFF; - zrf = 64'hBFE0000000000001; - ans = 64'h421000FF8002003D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3255427\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'hBFD0000000000000; - zrf = 64'h37E68BA030530633; - ans = 64'h37E68BA030530633; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3256041\n"); - end - xrf = 64'hFFDE1BB9448ED97D; - y = 64'hC1F7FFFFFBFFFFFE; - zrf = 64'h3F2FFF001FFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3256655\n"); - end - xrf = 64'h41EFFFFFEFFBFFFE; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h0000000000000001; - ans = 64'hC1DFFFFFEFFBFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3257269\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'hB8154E3AC4D65B24; - zrf = 64'h7FEFFFBFFFFFFFF8; - ans = 64'h7FEFFFBFFFFFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3257883\n"); - end - xrf = 64'hC03FFFFF9FFFFFFF; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h7FF1A6DF1C455395; - ans = 64'h7FF9A6DF1C455395; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3258497\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'hE41FB4561FAB2216; - zrf = 64'h4010000000000001; - ans = 64'h4010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3259111\n"); - end - xrf = 64'h3979F06890CEA607; - y = 64'h43DFFFF000FFFFFF; - zrf = 64'h3E0020001FFFFFFF; - ans = 64'h3E00267C36E65A77; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3259725\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'hBFE0000000000001; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3260339\n"); - end - xrf = 64'h381DFFDFFFFFFFFE; - y = 64'hDE8FBFFFFFFF7FFF; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hD6BDC3E03FFF87FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3260953\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h3E59CC299DB7AD28; - ans = 64'h3E59CC299DB7AD28; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3261567\n"); - end - xrf = 64'hC0357882E409903D; - y = 64'h413F000200000000; - zrf = 64'h3FF0000000FFFFDF; - ans = 64'hC184CCC01C7171FB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3262181\n"); - end - xrf = 64'hC04F7439462990DF; - y = 64'hBFF0000000000000; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3262795\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'hC1C0000401FFFFFF; - zrf = 64'h49FEFFFFFFFFEFFF; - ans = 64'h49FEFFFFFFFFEFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3263409\n"); - end - xrf = 64'h3E7FFFFFFEFC0000; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h41C0EA1AD0C683E5; - ans = 64'h41C0EA1AD0C683E3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3264023\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h3FDCE1B5FD249CA2; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h400FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3264637\n"); - end - xrf = 64'h4D70000080000200; - y = 64'hB815E6661713B195; - zrf = 64'hC270400000000006; - ans = 64'hC595E666C646E50E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3265251\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'hC000000000000000; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3265865\n"); - end - xrf = 64'hBFF0000000013FFF; - y = 64'h0010000000800002; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hBCAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3266479\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'hBC0FFFFFFFFBDFFF; - ans = 64'hBC0FFFFFFFFBDFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3267093\n"); - end - xrf = 64'h43F1400000000000; - y = 64'h7FF1FFFFFFFFF7FF; - zrf = 64'hC03376A99788577F; - ans = 64'h7FF9FFFFFFFFF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3267707\n"); - end - xrf = 64'hC03FFFFEFFFC0000; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3268321\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h3CA9266BE80A93FD; - zrf = 64'h3FE0000000000002; - ans = 64'h3FE0000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3268935\n"); - end - xrf = 64'h3E40000000002800; - y = 64'hC010000000000001; - zrf = 64'hC1FFCEF695EE509D; - ans = 64'hC1FFCEF695EE509D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3269549\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h43D0000001F7FFFF; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h3FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3270163\n"); - end - xrf = 64'h40100001FFFFFFFA; - y = 64'h268FFC000000FFFF; - zrf = 64'hC7FBC385A0705522; - ans = 64'hC7FBC385A0705522; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3270777\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3271391\n"); - end - xrf = 64'h5BC00000000001FB; - y = 64'hC32FF769DD7FB534; - zrf = 64'hBCA0000000000000; - ans = 64'hDEFFF769DD7FB929; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3272005\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; + x = 64'h8000000000000000; y = 64'hC340000000000001; - zrf = 64'h37F3BB17F4F23CA5; - ans = 64'h37F3BB17F4F23CA5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3272619\n"); - end - xrf = 64'hC1C16F9BFFD282C8; - y = 64'h402FFF8000000007; - zrf = 64'hAF200807FFFFFFFF; - ans = 64'hC2016F5641628382; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3273233\n"); - end - xrf = 64'h001FFFFFFFFFF0FF; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3273847\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h0011FE8BFC8537FA; - zrf = 64'hBD5FFFFFFFF7FFFE; - ans = 64'hBD5FFFFFFFF7FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3274461\n"); - end - xrf = 64'hC2E0002000000040; - y = 64'hFFE0000000000000; - zrf = 64'h435AC2FE89704E9A; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3275075\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h7FF7FFFFDFFFFFFF; - zrf = 64'h3FF0000000000000; - ans = 64'h7FFFFFFFDFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3275689\n"); - end - xrf = 64'h444FFFFA00000000; - y = 64'hC49FDFFFBFFFFFFE; - zrf = 64'h491FFFFFFFFEFFFF; - ans = 64'h491808018E7EFCFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3276303\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hC000000000000000; - ans = 64'h3FFFFFFFFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3276917\n"); - end - xrf = 64'h3FE7F167081042E5; - y = 64'hACCFFFFFFBFF8000; - zrf = 64'h8010000000000001; - ans = 64'hACC7F1670511B63E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3277531\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'hFFF0000000000000; - zrf = 64'h3A2000007FFFFBFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3278145\n"); - end - xrf = 64'hBF8FFFFFFFC01000; - y = 64'h001FEFFFFFFFFFFC; - zrf = 64'h396FFFFFFFFFFC7F; - ans = 64'h396FFFFFFFFFFC7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3278759\n"); - end - xrf = 64'h37EFF0F499363D92; - y = 64'hFFF0000000000001; - zrf = 64'hC340000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3279373\n"); - end - xrf = 64'h800FFFFFFFFFFFFF; - y = 64'h43EFFFF7FFFFFFFD; - zrf = 64'h412E65857660BD6A; - ans = 64'h412E65857660BD6A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3279987\n"); - end - xrf = 64'h3D8FFF7FFFEFFFFF; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h8010FFFF7FFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3280601\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h000FFF0000001FFE; - zrf = 64'h3FE0000000000001; - ans = 64'h3FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3281215\n"); - end - xrf = 64'h457F003FFFFFFFFF; - y = 64'h3F40000000000102; - zrf = 64'h002C04D8F9B9A9E4; - ans = 64'h44CF0040000001F3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3281829\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h0000000000000001; - zrf = 64'hBFF0000000000001; + z = 64'hBFF0000000000001; ans = 64'hBFF0000000000001; rn = 1; rz = 0; @@ -251273,19 +73047,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -251301,12 +73075,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3282443\n"); + $fwrite(fp,"3129755\n"); end - xrf = 64'h4A0FFFFFFFFCFFFE; - y = 64'h37FFFFFFFF040000; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h421FFFFFFF00FFFE; + x = 64'h3FFFF7FFFFDFFFFF; + y = 64'hFFE0000000000000; + z = 64'hBFB97642758A8451; + ans = 64'hFFEFF7FFFFDFFFFF; rn = 1; rz = 0; rm = 0; @@ -251320,19 +73094,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -251348,12 +73122,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3283057\n"); + $fwrite(fp,"3131769\n"); end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h001000000FFFFBFE; - ans = 64'h001000000FFFFBFE; + x = 64'h900FFFFFE000FFFE; + y = 64'h381300275946B79C; + z = 64'hC340000120000000; + ans = 64'hC340000120000000; rn = 1; rz = 0; rm = 0; @@ -251367,19 +73141,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -251395,4946 +73169,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3283671\n"); + $fwrite(fp,"3133783\n"); end - xrf = 64'h800FFDFFFFFFFBFF; - y = 64'hBFAFDFFFF7FFFFFE; - zrf = 64'hBF11000000000400; - ans = 64'hBF11000000000400; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3284285\n"); - end - xrf = 64'hC1F0001FFFFFBFFF; - y = 64'h0010000000000000; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3284899\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h40403FFFFFFFFFFD; - zrf = 64'hAB0FDFFFFFFFFDFF; - ans = 64'hAB0FDFFFFFFFFDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3285513\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h480FC40000000000; - ans = 64'h480FC40000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3286127\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h80070F523EA30032; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3286741\n"); - end - xrf = 64'hC100FFFFFFFFEFFF; - y = 64'h7FFF83FFFFFFFFFE; - zrf = 64'hA2DFFFFFBFFFFFE0; - ans = 64'h7FFF83FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3287355\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h3CA0000000000000; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3287969\n"); - end - xrf = 64'h43DFFFFFFF0003FF; - y = 64'h42FA8B901194A63F; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3288583\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hC7E80000001FFFFF; - ans = 64'hC7E80000001FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3289197\n"); - end - xrf = 64'h000FF00000001000; - y = 64'h41EFFFFFFFFFFCFF; - zrf = 64'h43FFFFFFBFC00000; - ans = 64'h43FFFFFFBFC00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3289811\n"); - end - xrf = 64'h3FFFA9456A66B8C6; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3290425\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h35CFFFFBFFFFFFFE; - zrf = 64'h43F00800003FFFFE; - ans = 64'h43F00800003FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3291039\n"); - end - xrf = 64'h7FEEA44E583282BA; - y = 64'h3FD0000000000001; - zrf = 64'h404FFFF7FFFBFFFF; - ans = 64'h7FCEA44E583282BC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3291653\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'hB480000000000FF7; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h3CAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3292267\n"); - end - xrf = 64'h3E2FFFFF80003FFF; - y = 64'h4030FFFFFFFFFFFF; - zrf = 64'hC44FBFFFFFFFFFF7; - ans = 64'hC44FBFFFFFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3292881\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3293495\n"); - end - xrf = 64'hB2CFFF8000000001; - y = 64'hB88FFFFFFFFDF000; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3294109\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h3FE0000000000001; - zrf = 64'h0010000400000010; - ans = 64'h0008000400000011; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3294723\n"); - end - xrf = 64'h3F907FFF00000000; - y = 64'h40500007FFFFE000; - zrf = 64'hC1DFFFFFFFE04000; - ans = 64'hC1DFFFFFFF9E3FE3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3295337\n"); - end - xrf = 64'hB3300007FDFFFFFF; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'hC000000000000000; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3295951\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'hC00619E1A258A831; - zrf = 64'h434FDFFC00000000; - ans = 64'h434FDFFC00000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3296565\n"); - end - xrf = 64'h002F0007FFFFFFFE; - y = 64'h3FF0000000000000; - zrf = 64'h40C0000003FFFFFC; - ans = 64'h40C0000003FFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3297179\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h801FFFF7FBFFFFFE; - zrf = 64'h3CA0000000000000; - ans = 64'h3CA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3297793\n"); - end - xrf = 64'hB27102DF0BD0BADE; - y = 64'hA57FFFFFA0000000; - zrf = 64'hBA727FFFFFFFFFFE; - ans = 64'hBA727FFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3298407\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hBFD0000000000000; - ans = 64'hBFD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3299021\n"); - end - xrf = 64'hBFB9F8E9AE43667C; - y = 64'hB7FFFE00000003FE; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3299635\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h4000000000000000; - zrf = 64'h405000027FFFFFFF; - ans = 64'h405000027FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3300249\n"); - end - xrf = 64'hC0103FDFFFFFFFFF; - y = 64'h5D1000001000000F; - zrf = 64'hAE6CFD66D57C4A6B; - ans = 64'hDD303FE0103FE00E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3300863\n"); - end - xrf = 64'h3FE00203FFFFFFFF; - y = 64'h4000000000000001; - zrf = 64'hBFF0000000000001; - ans = 64'h3F401FFFFFFFF801; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3301477\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h3850000007FFFFFC; - zrf = 64'h41E8000000004000; - ans = 64'h41E8000000004000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3302091\n"); - end - xrf = 64'hAA7000000010FFFF; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h0FE000400007FFFF; - ans = 64'hAA9000000010FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3302705\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h001FBFFFFFBFFFFE; - zrf = 64'h0010000000000001; - ans = 64'h0010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3303319\n"); - end - xrf = 64'h3ED0000000C00000; - y = 64'h3FDBCD5857809B86; - zrf = 64'hC03BFFFFFF7FFFFF; - ans = 64'hC03BFFFFE3B2A7A6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3303933\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h4010000000000001; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3304547\n"); - end - xrf = 64'hC2FFFFFFBFFFBFFE; - y = 64'h404FFFFFE1FFFFFF; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'hC34FFFFF43FF8073; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3305161\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h43CFFFFFFFFFEFFE; - ans = 64'h43CFFFFFFFFFEFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3305775\n"); - end - xrf = 64'hFFE0020000003FFF; - y = 64'hBF40000000FFFFFC; - zrf = 64'h0000003FFDFFFFFF; - ans = 64'h7F30020001005FFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3306389\n"); - end - xrf = 64'h41E0000010004000; - y = 64'h4340000000000000; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'h4530000010004000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3307003\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'hBD3FFFFC0000007F; - zrf = 64'h3FDFFFFFBFFFFDFF; - ans = 64'h3FDFFFFFBFFFFDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3307617\n"); - end - xrf = 64'h434A579E176B14FB; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h43EFFFFFFF7FFFFE; - ans = 64'h46AA579E176B16FA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3308231\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h3FD0000000007FFE; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h000BFFFFFFFFE000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3308845\n"); - end - xrf = 64'h47F0000007FC0000; - y = 64'hC5C08003FFFFFFFF; - zrf = 64'hB68FFEFFFFFDFFFF; - ans = 64'hCDC08004083BE1FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3309459\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h7FE0000000000000; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3310073\n"); - end - xrf = 64'h400EEFFFFFFFFFFF; - y = 64'hBF1FFDFFFFFFE000; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h401FFF8447BBFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3310687\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h3CA5272068BFA9C0; - ans = 64'hC00FFFFFFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3311301\n"); - end - xrf = 64'h4A5FFFFFFFFDFEFF; - y = 64'hC1DFFFFFFFBDFFFF; - zrf = 64'hC1EFC0000000003F; - ans = 64'hCC4FFFFFFFBBFEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3311915\n"); - end - xrf = 64'h419007FFFFFFFFBF; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3312529\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h9FBCFFFFFFFFFFFF; - zrf = 64'hADE01FF7FFFFFFFF; - ans = 64'hADE01FF7FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3313143\n"); - end - xrf = 64'hBFFCF103D80A58EE; - y = 64'h7FF0000000000001; - zrf = 64'hB7F8B48F2C8A4C4D; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3313757\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h66AFFFFFFFFFBFEF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3314371\n"); - end - xrf = 64'h3FBFFFE000000100; - y = 64'h401FED37CFC20DEA; - zrf = 64'hC10000000000027F; - ans = 64'hC0FFFFF0097413B9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3314985\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3315599\n"); - end - xrf = 64'h414FFFC007FFFFFF; - y = 64'hDC73D5385DFE4F27; - zrf = 64'h4010000000000000; - ans = 64'hDDD3D510B882E141; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3316213\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h8000000000000001; - zrf = 64'h403FFFFFFFFEFFEF; - ans = 64'h403FFFFFFFFEFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3316827\n"); - end - xrf = 64'hFFD000008000007F; - y = 64'hC0099588A9B1AE8D; - zrf = 64'h3D5F81AF27B7463A; - ans = 64'h7FE99589765DF4A6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3317441\n"); - end - xrf = 64'h47EFFFFF7FFFFFFF; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hBFD0000000000000; - ans = 64'hBFD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3318055\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h3D3FDFFFFFFFC000; - zrf = 64'hE7800010FFFFFFFE; - ans = 64'hE7800010FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3318669\n"); - end - xrf = 64'h3E0F7FBFFFFFFFFE; - y = 64'h8010000000000000; - zrf = 64'hC010FF7FFFFFFFFF; - ans = 64'hC010FF7FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3319283\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'hC500000007FFFFFA; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3319897\n"); - end - xrf = 64'hC1EFFFFFFF080000; - y = 64'hB7FF4C5FEC06BFEE; - zrf = 64'hC3FB1197B5C63C71; - ans = 64'hC3FB1197B5C63C71; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3320511\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h8000000000000000; - ans = 64'h0000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3321125\n"); - end - xrf = 64'hCD3EFFFFFFFFFC00; - y = 64'hC7E10000000FFFFF; - zrf = 64'h4000000000000001; - ans = 64'h55307800000F7DDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3321739\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'hBCA0000000000000; - zrf = 64'h3FE01FFFDFFFFFFF; - ans = 64'h3FE01FFFDFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3322353\n"); - end - xrf = 64'hC0F0000000F7FFFF; - y = 64'hC1DF7FEFFFFFFFFE; - zrf = 64'h4E2E00000000003F; - ans = 64'h4E2E00000000003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3322967\n"); - end - xrf = 64'h43C3FFFFFFC00000; - y = 64'hBCA0000000000001; - zrf = 64'hBCA0000000000001; - ans = 64'hC073FFFFFFC00001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3323581\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h43DFFFFFFFFE000F; - zrf = 64'hC3C000000FF80000; - ans = 64'hC3C000000FF80000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3324195\n"); - end - xrf = 64'h8020800000000008; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hBFC0800000000001; - ans = 64'hBFC0800000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3324809\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h4349D797CF3BC3F4; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3325423\n"); - end - xrf = 64'hBF9000007EFFFFFF; - y = 64'h4348DF378B8A6FE1; - zrf = 64'hCE00001FFFFFFFF7; - ans = 64'hCE00001FFFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3326037\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'hBFD0000000000001; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3326651\n"); - end - xrf = 64'hB5CFFFFBFF7FFFFF; - y = 64'h3FF0000000200000; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3327265\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h3B9FFFFE02000000; - ans = 64'h3B9FFFFE02000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3327879\n"); - end - xrf = 64'hBFFFFFFE20000000; - y = 64'h4DD00007FFFF7FFE; - zrf = 64'hB93E9C46925C398F; - ans = 64'hCDE000070FFF07FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3328493\n"); - end - xrf = 64'hBFCFFE0000000100; - y = 64'hBFE0000000000000; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h3FBFFE0000000100; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3329107\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'hBFE0000003FFFFFF; - zrf = 64'hC1CFFFFFFF7E0000; - ans = 64'hC1CFFFFFFF7E0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3329721\n"); - end - xrf = 64'hC7E0000103FFFFFF; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hC3FFEFFFFEFFFFFF; - ans = 64'h47E0000103FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3330335\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h8020000803FFFFFE; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3330949\n"); - end - xrf = 64'hB0D06C48D23CE86B; - y = 64'hC1C73954256DB898; - zrf = 64'h47F9EFC1D9AD8521; - ans = 64'h47F9EFC1D9AD8521; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3331563\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'hBFF0000000000000; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3332177\n"); - end - xrf = 64'hC7EFFFDFFFFDFFFF; - y = 64'hC98FE00000000000; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h518FDFE01FFE01FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3332791\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'hBFF0000000000001; - zrf = 64'h94D020000000001F; - ans = 64'h94D020000000001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3333405\n"); - end - xrf = 64'hC0300800003FFFFE; - y = 64'h8001FFFFF7FFFFFF; - zrf = 64'hC1D075BF2C245F2A; - ans = 64'hC1D075BF2C245F2A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3334019\n"); - end - xrf = 64'h400F6470568463BB; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hC01F6470568463B9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3334633\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'hBFDF31A46F1F02A3; - zrf = 64'hBFB0FFFFFFFFFFF7; - ans = 64'hBFB0FFFFFFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3335247\n"); - end - xrf = 64'hC01000000017FFFE; - y = 64'hC000000000000001; - zrf = 64'hEBAFFFFFFFE0003F; - ans = 64'hEBAFFFFFFFE0003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3335861\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h7FF0ECF8BC191E65; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'h7FF8ECF8BC191E65; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3336475\n"); - end - xrf = 64'h7FFFFFFFFFFFFEF7; - y = 64'hCABFF7FFFFFFFFE0; - zrf = 64'h7FD00001FFFF7FFE; - ans = 64'h7FFFFFFFFFFFFEF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3337089\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3337703\n"); - end - xrf = 64'hC3C077FFFFFFFFFF; - y = 64'h8000000000002010; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3338317\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'hC010000000000000; - zrf = 64'h800DFEDE47FBC1E2; - ans = 64'h00290090DC021F0B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3338931\n"); - end - xrf = 64'hBFC494FAB48A29ED; - y = 64'h3800000200000FFE; - zrf = 64'h9FAFEBFFFFFFFFFF; - ans = 64'hB7D494FD47299511; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3339545\n"); - end - xrf = 64'h7FDBFFFFFBFFFFFF; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h8000000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3340159\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h434FFFC008000000; - zrf = 64'hFFEFFFFFFFF8001F; - ans = 64'hFFEFFFFFFFF8001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3340773\n"); - end - xrf = 64'h418FFDFF80000000; - y = 64'hC340000000000000; - zrf = 64'hC02FFFFFFFFF003F; - ans = 64'hC4DFFDFF80000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3341387\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h43E0040000000000; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3342001\n"); - end - xrf = 64'h00200005FFFFFFFE; - y = 64'h950FFFFF7FFFFFF0; - zrf = 64'hB8039E96058D8A71; - ans = 64'hB8039E96058D8A71; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3342615\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3343229\n"); - end - xrf = 64'hC34FFC00000FFFFF; - y = 64'h41C7FFFFFFFFFFFE; - zrf = 64'h3FD0000000000001; - ans = 64'hC527FD00000BFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3343843\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h41D041FFFFFFFFFE; - ans = 64'h41D041FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3344457\n"); - end - xrf = 64'hC030000000001FFE; - y = 64'hB8178767331561B7; - zrf = 64'h3DA0080000000080; - ans = 64'h3DA0080000000080; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3345071\n"); - end - xrf = 64'hD1F00007FE000000; - y = 64'hFFE0000000000001; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3345685\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'h37FFFFFFFFFFFD7F; - zrf = 64'h3F3FFF800000007E; - ans = 64'h3F3FFF800000007E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3346299\n"); - end - xrf = 64'h000FFFEFDFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h4014569BF0D38E3F; - ans = 64'h3FF15AB0434E3904; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3346913\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'hC7F00E76DCEA4AE9; - zrf = 64'hC000000000000001; - ans = 64'hC000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3347527\n"); - end - xrf = 64'h3FCFFFFFFFEFFFF6; - y = 64'h4050008000000010; - zrf = 64'hC1FFEFFFEFFFFFFE; - ans = 64'hC1FFEFFFEEFFF7FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3348141\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; + x = 64'h8000000000000000; y = 64'hFFF0000000000001; - zrf = 64'h4010000000000001; + z = 64'h4340000000000000; ans = 64'hFFF8000000000001; rn = 1; rz = 0; @@ -256349,19 +73188,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -256377,4194 +73216,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3348755\n"); + $fwrite(fp,"3135797\n"); end - xrf = 64'h4003FFFFFFFFFFFC; - y = 64'h3B9FFFFFFFFFFF87; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CB00013FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3349369\n"); - end - xrf = 64'h800FFFFFFFFFFFFE; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hBF51FFFFC0000000; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3349983\n"); - end - xrf = 64'h42007FFFFFFFFFFE; - y = 64'hC05FFFFFFFDFE000; - zrf = 64'h7FF010000000000E; - ans = 64'h7FF810000000000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3350597\n"); - end - xrf = 64'h3FD0000000BFFFFE; - y = 64'h0000000000000000; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3351211\n"); - end - xrf = 64'h8010000000000000; - y = 64'hC03FFFFBFFFFF800; - zrf = 64'h3EEFFFFFFFFFFFDD; - ans = 64'h3EEFFFFFFFFFFFDD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3351825\n"); - end - xrf = 64'hC7EFFFFFFFFFFDFF; - y = 64'h0000000000000001; - zrf = 64'hBF6FFFFF03FFFFFE; - ans = 64'hBF6FFFFF03FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3352439\n"); - end - xrf = 64'h8010000000000000; - y = 64'hBD4FFFFFFFFFF7FF; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3353053\n"); - end - xrf = 64'h47F0000000082000; - y = 64'h37FF5000285F803E; - zrf = 64'h3FEFFE0000000100; - ans = 64'h4007A7801437B3AF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3353667\n"); - end - xrf = 64'h8010000000000000; - y = 64'h0010000000000000; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h400FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3354281\n"); - end - xrf = 64'h3810000000800003; - y = 64'h3041E7047E3F25CD; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h2861E7047ECE5DF4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3354895\n"); - end - xrf = 64'h8010000000000000; - y = 64'h0010000000000001; - zrf = 64'h47F9FFFFFFFFFFFE; - ans = 64'h47F9FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3355509\n"); - end - xrf = 64'hE59F8003FFFFFFFF; - y = 64'hBFD02EA216C7C36A; - zrf = 64'h41CFFFFFFF7FEFFF; - ans = 64'h657FDBD32881CE6A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3356123\n"); - end - xrf = 64'hD2F03FFFFBFFFFFE; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3356737\n"); - end - xrf = 64'h8010000000000000; - y = 64'h402382A8B2E80B9B; - zrf = 64'hBFB0010004000000; - ans = 64'hBFB0010004000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3357351\n"); - end - xrf = 64'h403FF7FFFFFFFFFB; - y = 64'h3CA0000000000000; - zrf = 64'h001FBFFFFFFFFDFF; - ans = 64'h3CEFF7FFFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3357965\n"); - end - xrf = 64'h8010000000000000; - y = 64'h400FFFFFFFC00400; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hBFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3358579\n"); - end - xrf = 64'hBCA00000003FFFFE; - y = 64'h7FD79FFD9502BA89; - zrf = 64'hFFE03FF000000000; - ans = 64'hFFE03FF000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3359193\n"); - end - xrf = 64'h8010000000000000; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h3FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3359807\n"); - end - xrf = 64'h3E400020FFFFFFFE; - y = 64'hC10F7FFBFFFFFFFF; - zrf = 64'h0010000000000000; - ans = 64'hBF5F803CF7F7BFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3360421\n"); - end - xrf = 64'h8010000000000000; - y = 64'h3FD0000000000000; - zrf = 64'hB81FFFFFFFFF80FE; - ans = 64'hB81FFFFFFFFF80FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3361035\n"); - end - xrf = 64'h3FDFFFDFFFF7FFFE; - y = 64'h3FF000010FFFFFFE; - zrf = 64'h401FFFBFFFFFF000; - ans = 64'h4020FFDF10FFA700; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3361649\n"); - end - xrf = 64'h3F0FFFBFFFFDFFFE; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3362263\n"); - end - xrf = 64'h8010000000000000; - y = 64'hC00FFFFFF8001FFF; - zrf = 64'hC7F00000FFFDFFFE; - ans = 64'hC7F00000FFFDFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3362877\n"); - end - xrf = 64'hBFA0003FFFFFF000; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'hC049FFFFFFFFFFFF; - ans = 64'hC04A020007FFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3363491\n"); - end - xrf = 64'h8010000000000000; - y = 64'h800FFFDFFFFFDFFF; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3364105\n"); - end - xrf = 64'hBFDF800000007FFF; - y = 64'h380B8EDE6D7386ED; - zrf = 64'hAAF0001FFFFFF000; - ans = 64'hB7FB20A2F3BE270C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3364719\n"); - end - xrf = 64'h8010000000000000; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h3FF0000000000000; - ans = 64'h3FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3365333\n"); - end - xrf = 64'h41EF000000007FFF; - y = 64'hBE6FFF7FFFFF7FFF; - zrf = 64'h0000000000000001; - ans = 64'hC06EFF84000003FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3365947\n"); - end - xrf = 64'h8010000000000000; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h4060000000100007; - ans = 64'h4060000000100007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3366561\n"); - end - xrf = 64'hBFDFFC90D6E1FC1F; - y = 64'h3CA1FFFFFFFFEFFE; - zrf = 64'hBFE66AD464A87AAC; - ans = 64'hBFE66AD464A87AAD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3367175\n"); - end - xrf = 64'h43E00007FFEFFFFE; - y = 64'h3FF0000000000001; - zrf = 64'h4010000000000001; - ans = 64'h43E00007FFEFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3367789\n"); - end - xrf = 64'h8010000000000000; - y = 64'h522FFFFFFBFBFFFF; - zrf = 64'h7FFFFFFFFFFBFFF7; - ans = 64'h7FFFFFFFFFFBFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3368403\n"); - end - xrf = 64'h37EFFFFFDFFFFF7F; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hC02F5071BEF1B839; - ans = 64'hC02F5071BEF1B839; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3369017\n"); - end - xrf = 64'h8010000000000000; - y = 64'hFFEFFFFF77FFFFFE; - zrf = 64'hBFD0000000000001; - ans = 64'h400DFFFF77FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3369631\n"); - end - xrf = 64'hC7F7EBA22F2EA5FF; - y = 64'h40DFFFFF80000002; - zrf = 64'h4061000010000000; - ans = 64'hC8E7EBA1CF801D44; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3370245\n"); - end - xrf = 64'h8010000000000000; - y = 64'h4000000000000001; - zrf = 64'h3FE0000000000001; - ans = 64'h3FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3370859\n"); - end - xrf = 64'hBFE8329734DA71DB; - y = 64'hC7EFFF7FFFFFFFFA; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3371473\n"); - end - xrf = 64'h8010000000000000; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h40D0000000013FFF; - ans = 64'h40D0000000013FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3372087\n"); - end - xrf = 64'hB7E4BBDEDAC95C09; - y = 64'hF080000000000016; - zrf = 64'hB7EFFFFFF8000003; - ans = 64'h6874BBDEDAC95C26; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3372701\n"); - end - xrf = 64'hCC9FFFFFFF840000; - y = 64'h4010000000000000; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'hCCBFFFFFFF840000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3373315\n"); - end - xrf = 64'h8010000000000000; - y = 64'h57ADB1B7BA5F902C; - zrf = 64'h4340800000FFFFFE; - ans = 64'h4340800000FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3373929\n"); - end - xrf = 64'hBAB0000100000400; - y = 64'h4010000000000001; - zrf = 64'hBFBFFF8003FFFFFF; - ans = 64'hBFBFFF8003FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3374543\n"); - end - xrf = 64'h8010000000000000; - y = 64'h7FE00000007FFFC0; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC0000000007FFFC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3375157\n"); - end - xrf = 64'h47E14BC9A7ABAD71; - y = 64'h7FD29E75366A36B5; - zrf = 64'hEB3FFFFE00000FFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3375771\n"); - end - xrf = 64'h8010000000000000; - y = 64'h4340000000000000; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3376385\n"); - end - xrf = 64'hC1F0000000020020; - y = 64'hC0E00080007FFFFE; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3376999\n"); - end - xrf = 64'h8010000000000000; - y = 64'h4340000000000001; - zrf = 64'hC7F400FFFFFFFFFE; - ans = 64'hC7F400FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3377613\n"); - end - xrf = 64'hC1C69CCD52EC0983; - y = 64'hD3E00000000FEFFF; - zrf = 64'h0910002000004000; - ans = 64'h55B69CCD53028FB2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3378227\n"); - end - xrf = 64'hFFDA2BDB043076F0; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3378841\n"); - end - xrf = 64'h8010000000000000; - y = 64'h40707FFFFBFFFFFF; - zrf = 64'h41CFFFC00003FFFF; - ans = 64'h41CFFFC00003FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3379455\n"); - end - xrf = 64'hC16A265035CB0A3D; - y = 64'h7FE0000000000000; - zrf = 64'hBFEFFDFFFF000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3380069\n"); - end - xrf = 64'h8010000000000000; - y = 64'h3FF0000FFFFFFFFD; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h80280007FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3380683\n"); - end - xrf = 64'h434000FFFFFFE000; - y = 64'hA167850B540C93BE; - zrf = 64'h4020100007FFFFFE; - ans = 64'h4020100007FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3381297\n"); - end - xrf = 64'h8010000000000000; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3381911\n"); - end - xrf = 64'h47EE080000000000; - y = 64'h3EDFFFF83FFFFFFE; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3382525\n"); - end - xrf = 64'h8010000000000000; - y = 64'h7FF0000000000000; - zrf = 64'hB81B02DA624F85A3; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3383139\n"); - end - xrf = 64'h8000000000000201; - y = 64'hA6D1000000000040; - zrf = 64'h3E4FFF7DFFFFFFFF; - ans = 64'h3E4FFF7DFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3383753\n"); - end - xrf = 64'h40D3FFFFFF7FFFFF; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h3FF0000000000000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3384367\n"); - end - xrf = 64'h8010000000000000; - y = 64'h401825A58D846616; - zrf = 64'hBFF0FFFBFFFFFFFF; - ans = 64'hBFF0FFFBFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3384981\n"); - end - xrf = 64'h801100000001FFFF; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h3A2401EDCE8EAE88; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3385595\n"); - end - xrf = 64'h8010000000000000; - y = 64'h4FE000000000077F; - zrf = 64'h8010000000000000; - ans = 64'h900000000000077F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3386209\n"); - end - xrf = 64'h402000001000007F; - y = 64'hC3D0000010003FFF; - zrf = 64'h434FFFFFBFFFF7FE; - ans = 64'hC3FFFC004008811D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3386823\n"); - end - xrf = 64'h8010000000000000; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h3CA0000000000000; - ans = 64'h3CA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3387437\n"); - end - xrf = 64'h405FF80000000FFF; - y = 64'h55200000FFBFFFFF; - zrf = 64'hC340000000000001; - ans = 64'h558FF801FF002FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3388051\n"); - end - xrf = 64'h8010000000000000; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h41E953F84305CBE0; - ans = 64'h41E953F84305CBE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3388665\n"); - end - xrf = 64'h9C10100000001FFF; - y = 64'h3CA000000000FC00; - zrf = 64'hC1E0B989A320F196; - ans = 64'hC1E0B989A320F196; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3389279\n"); - end - xrf = 64'h38132ABE4909F276; - y = 64'h8010000000000001; - zrf = 64'h3FE0000000000001; - ans = 64'h3FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3389893\n"); - end - xrf = 64'h8010000000000000; - y = 64'h30EFFFFFF01FFFFF; - zrf = 64'h3FC232FDBD2A9184; - ans = 64'h3FC232FDBD2A9184; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3390507\n"); - end - xrf = 64'hF3FFFFFF00007FFF; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h41E0040000007FFE; - ans = 64'h41E0040000007FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3391121\n"); - end - xrf = 64'h8010000000000000; - y = 64'hFFF0000000008004; - zrf = 64'h8000000000000001; - ans = 64'hFFF8000000008004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3391735\n"); - end - xrf = 64'h24107FFFFFFFFFFE; - y = 64'hC0100400000000FE; - zrf = 64'h401DD6230D9BE81D; - ans = 64'h401DD6230D9BE81D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3392349\n"); - end - xrf = 64'h8010000000000000; - y = 64'hBCA0000000000001; - zrf = 64'h0010000000000001; - ans = 64'h0010000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3392963\n"); - end - xrf = 64'h37EFFFFFFF8001FF; - y = 64'h40EFFFD7FFFFFFFF; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3393577\n"); - end - xrf = 64'h8010000000000000; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h3FEFF7FFBFFFFFFF; - ans = 64'h3FEFF7FFBFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3394191\n"); - end - xrf = 64'h41BFFF7FFFFFFBFE; - y = 64'hC0291CCC009FE8EF; - zrf = 64'h7FFFFFFFC000000E; - ans = 64'h7FFFFFFFC000000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3394805\n"); - end - xrf = 64'hC0120003FFFFFFFF; - y = 64'hBFD0000000000000; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FFA0003FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3395419\n"); - end - xrf = 64'h8010000000000000; - y = 64'h80100000FFFFFDFF; - zrf = 64'h6DC07FFFFFFFBFFF; - ans = 64'h6DC07FFFFFFFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3396033\n"); - end - xrf = 64'h3AB6A4F1D7C0B087; - y = 64'hBFD0000000000001; - zrf = 64'h3FF00000800000FF; - ans = 64'h3FF00000800000FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3396647\n"); - end - xrf = 64'h8010000000000000; - y = 64'hBF7D582DBB88D647; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3397261\n"); - end - xrf = 64'hC3E0000002400000; - y = 64'h00100003FFFFFFFB; - zrf = 64'h43E08000000000FF; - ans = 64'h43E08000000000FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3397875\n"); - end - xrf = 64'h8010000000000000; - y = 64'hBFE0000000000000; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h0017FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3398489\n"); - end - xrf = 64'h43FA9DBB168CCA00; - y = 64'h417000000000F800; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'h457A9DBB168E668D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3399103\n"); - end - xrf = 64'h8010000000000000; - y = 64'hBFE0000000000001; - zrf = 64'hBE027E2F4F0BA6BA; - ans = 64'hBE027E2F4F0BA6BA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3399717\n"); - end - xrf = 64'h381FFFFFFE0FFFFE; - y = 64'hBF4FFFC002000000; - zrf = 64'h3CADFFFFFFFDFFFF; - ans = 64'h3CADFFFFFFFDFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3400331\n"); - end - xrf = 64'hC04000201FFFFFFE; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h404000201FFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3400945\n"); - end - xrf = 64'h8010000000000000; - y = 64'hBCAFFFFF7FFFEFFE; - zrf = 64'hC1FFFFF8007FFFFF; - ans = 64'hC1FFFFF8007FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3401559\n"); - end - xrf = 64'hBF1FC01FFFFFFFFE; - y = 64'hBFF0000000000000; - zrf = 64'hC3C02000000003FE; - ans = 64'hC3C02000000003FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3402173\n"); - end - xrf = 64'h8010000000000000; - y = 64'h43FD5D2E92764475; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3402787\n"); - end - xrf = 64'hBE0ED055692EBF18; - y = 64'hFFFFFFFFFFFF03FE; - zrf = 64'h37EA1A5EB2077F40; - ans = 64'hFFFFFFFFFFFF03FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3403401\n"); - end - xrf = 64'h8010000000000000; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'hFFFFFFFFFFFFFFFE; + x = 64'hB46FF00000003FFF; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h406FFFFFFF7FFFF8; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -260579,19 +73235,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -260607,12 +73263,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3404015\n"); + $fwrite(fp,"3137811\n"); end - xrf = 64'h7FF0010000000007; - y = 64'h400FFFFFE0000004; - zrf = 64'hC000000000000000; - ans = 64'h7FF8010000000007; + x = 64'h47E00010007FFFFF; + y = 64'h40266EBEA38FE729; + z = 64'hC1F0001001FFFFFE; + ans = 64'h48166ED5130200AD; rn = 1; rz = 0; rm = 0; @@ -260626,19 +73282,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -260654,12 +73310,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3404629\n"); + $fwrite(fp,"3139825\n"); end - xrf = 64'h8010000000000000; - y = 64'hC000000000000000; - zrf = 64'h400FFFFFFF7FFFFE; - ans = 64'h400FFFFFFF7FFFFE; + x = 64'h8000000000000001; + y = 64'h0010000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -260673,19 +73329,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -260701,12 +73357,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3405243\n"); + $fwrite(fp,"3141839\n"); end - xrf = 64'hBF34EA21CDC8CADA; - y = 64'hC0800200000FFFFF; - zrf = 64'h401FFFFFFEEFFFFF; - ans = 64'h402053B2FBC05DB8; + x = 64'hC010008000000002; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hC34D53BC32062817; + ans = 64'hC34D53BC32062817; rn = 1; rz = 0; rm = 0; @@ -260720,19 +73376,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -260748,12 +73404,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3405857\n"); + $fwrite(fp,"3143853\n"); end - xrf = 64'hC9EFFFF800003FFF; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h3CA0000000000000; - ans = 64'h4A0FFFF800003FFE; + x = 64'h3C20001FFEFFFFFF; + y = 64'h1DA4B9C4C2406E55; + z = 64'hB800000DFFFFFFFF; + ans = 64'hB800000DFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -260767,19 +73423,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -260795,12 +73451,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3406471\n"); + $fwrite(fp,"3145867\n"); end - xrf = 64'h8010000000000000; - y = 64'h7FFFFFFFFFDFFFFF; - zrf = 64'h480FFFFFFFEFFC00; - ans = 64'h7FFFFFFFFFDFFFFF; + x = 64'h8000000000000001; + y = 64'h3FD0000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -260814,19 +73470,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -260842,12 +73498,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3407085\n"); + $fwrite(fp,"3147881\n"); end - xrf = 64'hC81F7FFFFFFFFEFF; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'hBF9AE67AFF0983D8; - ans = 64'h483F7FFFFFFFFEFD; + x = 64'hC3FFFFFFFFEFFEFF; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hC01FFFFC07FFFFFF; + ans = 64'hC3EFFFFFFFEFFEFD; rn = 1; rz = 0; rm = 0; @@ -260861,19 +73517,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -260889,12 +73545,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3407699\n"); + $fwrite(fp,"3149895\n"); end - xrf = 64'h8010000000000000; - y = 64'h43C3AED15D7EED2D; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; + x = 64'hBEF0000000003FFB; + y = 64'h7FFFFFFFFFFFA000; + z = 64'h3DC8000000040000; + ans = 64'h7FFFFFFFFFFFA000; rn = 1; rz = 0; rm = 0; @@ -260908,19 +73564,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -260936,12 +73592,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3408313\n"); + $fwrite(fp,"3151909\n"); end - xrf = 64'h47F00000FFFFBFFF; - y = 64'h006FF7FFFFFFFFFB; - zrf = 64'h7FEFF7FF80000000; - ans = 64'h7FEFF7FF80000000; + x = 64'h8000000000000001; + y = 64'h3FF0000000000000; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; rn = 1; rz = 0; rm = 0; @@ -260955,19 +73611,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -260983,12 +73639,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3408927\n"); + $fwrite(fp,"3153923\n"); end - xrf = 64'h8010000000000000; - y = 64'hC010000000000001; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; + x = 64'h480473FEE0C956B1; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hBD7BBDB3AEF5F51A; + ans = 64'h481473FEE0C956B0; rn = 1; rz = 0; rm = 0; @@ -261002,19 +73658,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -261030,11 +73686,481 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3409541\n"); + $fwrite(fp,"3155937\n"); end - xrf = 64'h37F0000003FFFFF7; - y = 64'hBF23FFFF7FFFFFFF; - zrf = 64'hBFF0000000000001; + x = 64'hBF1FFFFFFFFFEFBE; + y = 64'h4060001FFF7FFFFE; + z = 64'hBFB9717E7198CA76; + ans = 64'hBFBD71867178C86D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3157951\n"); + end + x = 64'h8000000000000001; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3159965\n"); + end + x = 64'hC1DFFFFFC0000FFE; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h8013FBFFFFFFFFFF; + ans = 64'hC20FFFFFC0000FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3161979\n"); + end + x = 64'h43100200003FFFFF; + y = 64'hB7E000000DFFFFFE; + z = 64'h47EF5361DE548D5B; + ans = 64'h47EF5361DE548D5B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3163993\n"); + end + x = 64'h8000000000000001; + y = 64'h434FFFFFFFFFFFFE; + 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,"3166007\n"); + end + x = 64'hB7EFFFFFFF800000; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'hBF224D4C54ADBF54; + ans = 64'hF7EFFFFFFF7FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3168021\n"); + end + x = 64'hC00001FFFFFFFDFE; + y = 64'h47FFFFFFFFF3FFFF; + z = 64'hCD8000001F7FFFFE; + ans = 64'hCD8000001F7FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3170035\n"); + end + x = 64'h8000000000000001; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3172049\n"); + end + x = 64'hBFBF0000000000FE; + y = 64'h8000000000000001; + z = 64'hE17FFFFFFFFF8007; + ans = 64'hE17FFFFFFFFF8007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3174063\n"); + end + x = 64'h7A2E9622E5CA04A5; + y = 64'h21F6A376ABEF6748; + z = 64'hBFEFFF80000007FF; + ans = 64'h5C35A3762DB52E1B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3176077\n"); + end + x = 64'h8000000000000001; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hBFF0000000000001; ans = 64'hBFF0000000000001; rn = 1; rz = 0; @@ -261049,19 +74175,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -261077,4007 +74203,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3410155\n"); + $fwrite(fp,"3178091\n"); end - xrf = 64'h8010000000000000; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h43C8E9C48CCC5395; - ans = 64'h43C8E9C48CCC5395; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3410769\n"); - end - xrf = 64'h3F50F7FFFFFFFFFF; - y = 64'hC1E0000017FFFFFF; - zrf = 64'hBFAE4E3B838772A5; - ans = 64'hC140F80021078EDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3411383\n"); - end - xrf = 64'h3FFFFF07FFFFFFFF; - y = 64'hC340000000000001; - zrf = 64'h0010000000000001; - ans = 64'hC34FFF0800000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3411997\n"); - end - xrf = 64'h8010000000000000; - y = 64'hBFC1000000000002; - zrf = 64'h37E6F76741D61EDF; - ans = 64'h37E6F76741D61EDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3412611\n"); - end - xrf = 64'h3ED7BBC3B97CC198; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hC7F1001FFFFFFFFF; - ans = 64'hC7F1001FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3413225\n"); - end - xrf = 64'h8010000000000000; - y = 64'hC1FFFFF7FFEFFFFF; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3413839\n"); - end - xrf = 64'hBFF0000000880000; - y = 64'h43DFE00000020000; - zrf = 64'h3C9000000FBFFFFF; - ans = 64'hC3DFE0000110F000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3414453\n"); - end - xrf = 64'h8010000000000000; - y = 64'hFFE0000000000000; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3415067\n"); - end - xrf = 64'h455004000000003E; - y = 64'hC3C38570142B9A35; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hC9238A517030A567; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3415681\n"); - end - xrf = 64'h8010000000000000; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hB7FEFFF7FFFFFFFF; - ans = 64'h400FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3416295\n"); - end - xrf = 64'h41CE002000000000; - y = 64'h47E74F59B8787E2A; - zrf = 64'h404A24AB53AA6DE2; - ans = 64'h49C5DA7B6C4AAEC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3416909\n"); - end - xrf = 64'h40319890A0A917DD; - y = 64'hFFF0000000000000; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3417523\n"); - end - xrf = 64'h8010000000000000; - y = 64'hC0380007FFFFFFFF; - zrf = 64'hBCAFFFFFFFFEFC00; - ans = 64'hBCAFFFFFFFFEFC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3418137\n"); - end - xrf = 64'h43E0000FFFFFBFFE; - y = 64'hFFF0000000000001; - zrf = 64'hC1EFFBF7FFFFFFFF; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3418751\n"); - end - xrf = 64'h8010000000000000; - y = 64'h47EC85E3B2608045; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h401FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3419365\n"); - end - xrf = 64'h4462750B8EBD954D; - y = 64'h40366C327960A626; - zrf = 64'h457FC0FFFFFFFFFF; - ans = 64'h457FC1CEEE016087; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3419979\n"); - end - xrf = 64'h8010000000000000; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3420593\n"); - end - xrf = 64'h8C16F70C4AD7B5FF; - y = 64'hC0659F877D27364D; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3421207\n"); - end - xrf = 64'h8010000000000001; - y = 64'h0000000000000001; - zrf = 64'h40400000001FFFFF; - ans = 64'h40400000001FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3421821\n"); - end - xrf = 64'h3FFFFE7FFFFFFFFF; - y = 64'hFFF07FBFFFFFFFFE; - zrf = 64'h37EEAC45D6E6F956; - ans = 64'hFFF87FBFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3422435\n"); - end - xrf = 64'hC090000800000008; - y = 64'h000FFFFFFFFFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3423049\n"); - end - xrf = 64'h8010000000000001; - y = 64'h4030000080000400; - zrf = 64'h3814DAE88176666D; - ans = 64'h3814DAE88176666D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3423663\n"); - end - xrf = 64'hC3F00000FFF80000; - y = 64'h0010000000000000; - zrf = 64'h58200000000FFF00; - ans = 64'h58200000000FFF00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3424277\n"); - end - xrf = 64'h8010000000000001; - y = 64'hBE5FFFFFFFF9FFFE; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3424891\n"); - end - xrf = 64'h7FD0FFFC00000000; - y = 64'h245FFFFFFFFFFFF6; - zrf = 64'h001E996DE223F216; - ans = 64'h6440FFFBFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3425505\n"); - end - xrf = 64'h8010000000000001; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3426119\n"); - end - xrf = 64'h327FFFFFFFFF0FFF; - y = 64'h002FFFFFF000007E; - zrf = 64'hBFD0000000000000; - ans = 64'hBFD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3426733\n"); - end - xrf = 64'h8010000000000001; - y = 64'h3CA0000000000000; - zrf = 64'hBFEBFFFFFFF7FFFE; - ans = 64'hBFEBFFFFFFF7FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3427347\n"); - end - xrf = 64'h3D4AF0C44F073F7C; - y = 64'hB7EFFEFFFFFF7FFE; - zrf = 64'hC29271AA05B991D9; - ans = 64'hC29271AA05B991D9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3427961\n"); - end - xrf = 64'h0016FB8958D5CE7A; - y = 64'h3CA0000000000001; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3428575\n"); - end - xrf = 64'h8010000000000001; - y = 64'h40100200000007FE; - zrf = 64'hBE200000000C0000; - ans = 64'hBE200000000C0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3429189\n"); - end - xrf = 64'h417FFFFFFFFE00FF; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'hC3D0800200000000; - ans = 64'hC3D0800200000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3429803\n"); - end - xrf = 64'h8010000000000001; - y = 64'h4EB4F75D91518E6B; - zrf = 64'h4000000000000000; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3430417\n"); - end - xrf = 64'h381FFFFFE3FFFFFE; - y = 64'hBFE0000000017FFF; - zrf = 64'h3FB9479D54939987; - ans = 64'h3FB9479D54939987; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3431031\n"); - end - xrf = 64'h8010000000000001; - y = 64'h3FD0000000000001; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3431645\n"); - end - xrf = 64'hC0000000003FFFFF; - y = 64'h3FEFFFFFFF801FFF; - zrf = 64'hBCA0000000000001; - ans = 64'hC000000000000FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3432259\n"); - end - xrf = 64'h8010000000000001; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'hB8F0000003FFFFBE; - ans = 64'hB8F0000003FFFFBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3432873\n"); - end - xrf = 64'h47CFF7FFFFFFFFFF; - y = 64'h000403FFFFFFFFFF; - zrf = 64'h4010000010000006; - ans = 64'h4010000010000006; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3433487\n"); - end - xrf = 64'h3E1F7FFFFFFDFFFE; - y = 64'h3FE0000000000000; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3434101\n"); - end - xrf = 64'h8010000000000001; - y = 64'hC02FFFFFFFFFFBFE; - zrf = 64'hC3CFFFFFFFFFFFEB; - ans = 64'hC3CFFFFFFFFFFFEB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3434715\n"); - end - xrf = 64'h403FFFFFFBFFFBFF; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h41FFFFFF80000040; - ans = 64'h41FFFFFF82000040; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3435329\n"); - end - xrf = 64'h8010000000000001; - y = 64'hBFCFFFFFFFFEFFF8; - zrf = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3435943\n"); - end - xrf = 64'hBFE000800000000E; - y = 64'hBF203FFFFFBFFFFE; - zrf = 64'hBFBDA817ACC5E05E; - ans = 64'hBFBDA4078C45F05E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3436557\n"); - end - xrf = 64'h8010000000000001; - y = 64'h3FF0000000000000; - zrf = 64'hC000000000000001; - ans = 64'hC000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3437171\n"); - end - xrf = 64'h7FE800000000003E; - y = 64'h8004DE935D68D1E8; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'hBFED37743074EBBB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3437785\n"); - end - xrf = 64'h8010000000000001; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hC800000000007FEF; - ans = 64'hC800000000007FEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3438399\n"); - end - xrf = 64'hCD0A506F0E26FC02; - y = 64'hBFADFFFFFFFFC000; - zrf = 64'hC5200003FFFBFFFF; - ans = 64'h4CC8AB681D4457A1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3439013\n"); - end - xrf = 64'hBAB03FFFFFFE0000; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3439627\n"); - end - xrf = 64'h8010000000000001; - y = 64'h26DFFFBFFF800000; - zrf = 64'h40D81EF424CFD2A4; - ans = 64'h40D81EF424CFD2A4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3440241\n"); - end - xrf = 64'hBFC6CE5CC791295B; - y = 64'h4000000000000001; - zrf = 64'h4800000010000008; - ans = 64'h4800000010000008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3440855\n"); - end - xrf = 64'h8010000000000001; - y = 64'hD6C0001FFFFFFFFE; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3441469\n"); - end - xrf = 64'h0FD00005FFFFFFFF; - y = 64'h38002000000001FF; - zrf = 64'h403FFFFFFFFFFF7F; - ans = 64'h403FFFFFFFFFFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3442083\n"); - end - xrf = 64'h8010000000000001; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3442697\n"); - end - xrf = 64'hBF3FFF8003FFFFFF; - y = 64'h3F9005FFFFFFFFFE; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hBEE005BFEA00BFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3443311\n"); - end - xrf = 64'h8010000000000001; - y = 64'h4010000000000001; - zrf = 64'hC3DFFFFFFF8FFFFF; - ans = 64'hC3DFFFFFFF8FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3443925\n"); - end - xrf = 64'hC1C0000800000010; - y = 64'hC801FFFFF0000000; - zrf = 64'h6B00000100000000; - ans = 64'h6B00000100000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3444539\n"); - end - xrf = 64'hC7F22D8469F0C3B1; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC8222D8469F0C3B0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3445153\n"); - end - xrf = 64'h8010000000000001; - y = 64'h3FEFFDFFEFFFFFFF; - zrf = 64'hBF8007FFFF800000; - ans = 64'hBF8007FFFF800000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3445767\n"); - end - xrf = 64'h4190000000000060; - y = 64'h4340000000000000; - zrf = 64'hBFD81177F4F07753; - ans = 64'h44E0000000000060; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3446381\n"); - end - xrf = 64'h8010000000000001; - y = 64'hB7EFDDFFFFFFFFFF; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3446995\n"); - end - xrf = 64'hC8000001F7FFFFFF; - y = 64'hB7FE00000003FFFF; - zrf = 64'hBFB0000FFFFFFFFE; - ans = 64'h400D80033103FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3447609\n"); - end - xrf = 64'h8010000000000001; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hBFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3448223\n"); - end - xrf = 64'h43DFFC00000FFFFE; - y = 64'h3E6F7FFFFF7FFFFE; - zrf = 64'h8000000000000000; - ans = 64'h425F7C0FFF8FCFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3448837\n"); - end - xrf = 64'h8010000000000001; - y = 64'h7FE0000000000000; - zrf = 64'hBF101FFFFFF7FFFF; - ans = 64'hC00000203FFFFFF1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3449451\n"); - end - xrf = 64'hAA50008000000000; - y = 64'hB7EFFFFF001FFFFE; - zrf = 64'hBFFFFFFFFFEFFE00; - ans = 64'hBFFFFFFFFFEFFE00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3450065\n"); - end - xrf = 64'h37FBFFFFFFEFFFFF; - y = 64'h7FE0000000000001; - zrf = 64'hC010000000000000; - ans = 64'h77EBFFFFFFF00001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3450679\n"); - end - xrf = 64'h8010000000000001; - y = 64'h800F7FFFFFFFFF80; - zrf = 64'h37B00000083FFFFF; - ans = 64'h37B00000083FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3451293\n"); - end - xrf = 64'h402FFFC07FFFFFFE; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h400FBBFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3451907\n"); - end - xrf = 64'h8010000000000001; - y = 64'hC0FFFFFFFFF01FFE; - zrf = 64'h3FD0000000000000; - ans = 64'h3FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3452521\n"); - end - xrf = 64'h000000000000007A; - y = 64'hC34B191A46C9F624; - zrf = 64'h41FFFFFFFFFDBFFE; - ans = 64'h41FFFFFFFFFDBFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3453135\n"); - end - xrf = 64'h8010000000000001; - y = 64'h7FF0000000000001; - zrf = 64'hBFE0000000000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3453749\n"); - end - xrf = 64'hBFFFFFBFFFFFBFFF; - y = 64'hCF7FF000003FFFFF; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3454363\n"); - end - xrf = 64'h8010000000000001; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h3FF2C214BD28AB14; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3454977\n"); - end - xrf = 64'hC3400007FFFFFBFF; - y = 64'h3E10000000200400; - zrf = 64'hBFA0010010000000; - ans = 64'hC160000801201010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3455591\n"); - end - xrf = 64'hC3CFEFFFFFEFFFFE; - y = 64'h8000000000000000; - zrf = 64'hC000000000000001; - ans = 64'hC000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3456205\n"); - end - xrf = 64'h8010000000000001; - y = 64'h402FFFF800000000; - zrf = 64'hBFFFFC01FFFFFFFE; - ans = 64'hBFFFFC01FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3456819\n"); - end - xrf = 64'h41D00000F7FFFFFF; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h41900000001BFFFE; - ans = 64'h41900000001BFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3457433\n"); - end - xrf = 64'h8010000000000001; - y = 64'hBE6FFE000000FFFF; - zrf = 64'h3CA0000000000001; - ans = 64'h3CA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3458047\n"); - end - xrf = 64'h47E2000FFFFFFFFF; - y = 64'h5EEB8AC00B21E1F9; - zrf = 64'h8000000003FFFFFE; - ans = 64'h66DEFC3397462958; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3458661\n"); - end - xrf = 64'h8010000000000001; - y = 64'h8010000000000000; - zrf = 64'hBFD0000000000001; - ans = 64'hBFD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3459275\n"); - end - xrf = 64'h401F5D0E48FDF300; - y = 64'hC27FFFFDFFFFFFFF; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3459889\n"); - end - xrf = 64'h8010000000000001; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h402403B9376E4ABD; - ans = 64'h402403B9376E4ABD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3460503\n"); - end - xrf = 64'hC7E0000000000102; - y = 64'h32CFFFFFFFFC07FF; - zrf = 64'h04CFFF7FFFFFFDFE; - ans = 64'hBABFFFFFFFFC0A03; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3461117\n"); - end - xrf = 64'h41F911036CBF63B6; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3461731\n"); - end - xrf = 64'h8010000000000001; - y = 64'h2AAAFFFFFFFFFFFF; - zrf = 64'hDF0FDD09B53983F3; - ans = 64'hDF0FDD09B53983F3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3462345\n"); - end - xrf = 64'hBEF001001FFFFFFF; + x = 64'hC080004000000100; y = 64'hBCA0000000000001; - zrf = 64'hBDE07FFFFFFFFC00; - ans = 64'hBDE07FFFFFFEFBF0; + z = 64'h36A000000000001B; + ans = 64'h3D30004000000101; rn = 1; rz = 0; rm = 0; @@ -265091,19 +74222,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -265119,12 +74250,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3462959\n"); + $fwrite(fp,"3180105\n"); end - xrf = 64'h8010000000000001; - y = 64'hC060000FFFFFFFF6; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h0080400FFFFFFFF7; + x = 64'h3F4FFFFFFFFFFE06; + y = 64'h3FE121D0404AF4CC; + z = 64'h403EF7A477CB376D; + ans = 64'h403EF7C6BB6BB803; rn = 1; rz = 0; rm = 0; @@ -265138,19 +74269,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -265166,247 +74297,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3463573\n"); + $fwrite(fp,"3182119\n"); end - xrf = 64'hC3C01FFFFFEFFFFF; - y = 64'h40200000001FFFFD; - zrf = 64'h43F003FFFFFBFFFE; - ans = 64'hC37C0000143FFDFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3464187\n"); - end - xrf = 64'h8010000000000001; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3464801\n"); - end - xrf = 64'hBE656A583A6372FE; - y = 64'hB81FFFFFFFC20000; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3465415\n"); - end - xrf = 64'h8010000000000001; - y = 64'hBFD0000000000001; - zrf = 64'h3EF00101FFFFFFFF; - ans = 64'h3EF00101FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3466029\n"); - end - xrf = 64'hC05D5279C4F75DDD; - y = 64'h410FBFFEFFFFFFFF; - zrf = 64'hBD90FF8000000000; - ans = 64'hC17D17D3E6D9A0F9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3466643\n"); - end - xrf = 64'hC01FF0000FFFFFFF; + x = 64'h8000000000000001; y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'h4007F0000FFFFFFF; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; rn = 1; rz = 0; rm = 0; @@ -265420,19 +74316,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -265448,59 +74344,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3467257\n"); + $fwrite(fp,"3184133\n"); end - xrf = 64'h8010000000000001; - y = 64'hC7FFBFFFFFFFFFF8; - zrf = 64'h3F7FFFFFFFFFFFFF; - ans = 64'h3F7FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3467871\n"); - end - xrf = 64'h3FD0000001C00000; + x = 64'hB81F130C997C7900; y = 64'hBFE0000000000000; - zrf = 64'hBA900000FFFFFFFF; - ans = 64'hBFC0000001C00000; + z = 64'h2F8FFFFFFB800000; + ans = 64'h380F130C997C7900; rn = 1; rz = 0; rm = 0; @@ -265514,19 +74363,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -265542,12 +74391,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3468485\n"); + $fwrite(fp,"3186147\n"); end - xrf = 64'h8010000000000001; - y = 64'h434C50942BB01F08; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h836C50942BB01F09; + x = 64'hC100007FFFFFFFBF; + y = 64'hB3FFFFFFFFFFFFFE; + z = 64'h36CFFFC00000000E; + ans = 64'h36CFFFC00200100E; rn = 1; rz = 0; rm = 0; @@ -265561,19 +74410,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -265589,4758 +74438,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3469099\n"); + $fwrite(fp,"3188161\n"); end - xrf = 64'hBFB000000807FFFF; - y = 64'h47EFF7FE00000000; - zrf = 64'hB7E07FFFFFFFBFFF; - ans = 64'hC7AFF7FE100BFAFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3469713\n"); - end - xrf = 64'h8010000000000001; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h800FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3470327\n"); - end - xrf = 64'h3FF001FFDFFFFFFE; - y = 64'h402EFFFFFFFFFC00; - zrf = 64'h4340000000000000; - ans = 64'h4340000000000008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3470941\n"); - end - xrf = 64'h8010000000000001; - y = 64'hBFF0000000000000; - zrf = 64'hB6E0000002200000; - ans = 64'hB6E0000002200000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3471555\n"); - end - xrf = 64'hC1FF800001FFFFFE; - y = 64'h4400000001FFFFF8; - zrf = 64'hB81F8000000003FF; - ans = 64'hC60F800005EFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3472169\n"); - end - xrf = 64'hAE5F801FFFFFFFFF; + x = 64'h8000000000000001; y = 64'hBFF0000000000001; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3472783\n"); - end - xrf = 64'h8010000000000001; - y = 64'h7FD00000000103FE; - zrf = 64'h3F900003FFFFDFFF; - ans = 64'hBFEF7FFFE00208FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3473397\n"); - end - xrf = 64'h253FFFFE01FFFFFF; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hBFDF800007FFFFFF; - ans = 64'hBFDF800007FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3474011\n"); - end - xrf = 64'h8010000000000001; - y = 64'hC097F535A94B8768; - zrf = 64'h0000000000000000; - ans = 64'h00B7F535A94B8769; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3474625\n"); - end - xrf = 64'hBFCFFFFFFF03FFFF; - y = 64'h7FFC04AA4A34A9A1; - zrf = 64'hB7E8A2BA0464A248; - ans = 64'h7FFC04AA4A34A9A1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3475239\n"); - end - xrf = 64'h8010000000000001; - y = 64'hC000000000000001; - zrf = 64'h8010000000000000; - ans = 64'h0010000000000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3475853\n"); - end - xrf = 64'h3FDFFEFFFFFFC000; - y = 64'hC1FFDFFFF8000000; - zrf = 64'h4010000000000001; - ans = 64'hC1EFDF00F7800040; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3476467\n"); - end - xrf = 64'h8010000000000001; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h2162E1C38925382F; - ans = 64'h2162E1C38925382F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3477081\n"); - end - xrf = 64'h41EFF7FFFEFFFFFE; - y = 64'hC00FFF7FFFFFFFFF; - zrf = 64'h4C40000007F7FFFE; - ans = 64'h4C40000007F7FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3477695\n"); - end - xrf = 64'hC420000FFDFFFFFF; - y = 64'hC010000000000000; - zrf = 64'hBFD0000000000001; - ans = 64'h4440000FFDFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3478309\n"); - end - xrf = 64'h8010000000000001; - y = 64'h37EFFFFFFFFFEEFE; - zrf = 64'h802FFFFFFFFFFDFE; - ans = 64'h802FFFFFFFFFFDFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3478923\n"); - end - xrf = 64'hBB9010000001FFFE; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h400FFFF80000003E; - ans = 64'h400FFFF80000003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3479537\n"); - end - xrf = 64'h8010000000000001; - y = 64'hC26FFFFFFFBFFF80; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3480151\n"); - end - xrf = 64'h3FBFFFFFFFFFF7FD; - y = 64'hB7FA36D046DE74F2; - zrf = 64'h422FFFFE00200000; - ans = 64'h422FFFFE00200000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3480765\n"); - end - xrf = 64'h8010000000000001; - y = 64'hC340000000000000; - zrf = 64'h8000000000000001; - ans = 64'h0360000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3481379\n"); - end - xrf = 64'h43FFBFFFFEFFFFFF; - y = 64'h1C97F43A22A60B85; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h400FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3481993\n"); - end - xrf = 64'h8010000000000001; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h002175F4C9217C07; - ans = 64'h0370000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3482607\n"); - end - xrf = 64'hC13FDC0000000000; - y = 64'hC6E98960D74C89F6; - zrf = 64'h26F007FEFFFFFFFF; - ans = 64'h48396CA64A5A53DB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3483221\n"); - end - xrf = 64'h380FFC000003FFFE; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCB00000FFE00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3483835\n"); - end - xrf = 64'h8010000000000001; - y = 64'h41EB3544B5D48790; - zrf = 64'h43CFFFFFF7FFFEFF; - ans = 64'h43CFFFFFF7FFFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3484449\n"); - end - xrf = 64'hC03000080000003F; - y = 64'hFFE0000000000001; - zrf = 64'h402007FFFDFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3485063\n"); - end - xrf = 64'h8010000000000001; - y = 64'hBF2F7FFFFFFBFFFF; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3485677\n"); - end - xrf = 64'hC1EFFFFC07FFFFFF; - y = 64'h4EF8FD99B216C7A4; - zrf = 64'h47FFFFFFFFFF8010; - ans = 64'hD0F8FD9698A2F7CD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3486291\n"); - end - xrf = 64'h8010000000000001; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3486905\n"); - end - xrf = 64'h7FEA9C0EFE0A98BD; - y = 64'h403E000400000000; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3487519\n"); - end - xrf = 64'h8010000000000001; - y = 64'hFFF0000000000001; - zrf = 64'hB7E0005FFFFFFFFE; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3488133\n"); - end - xrf = 64'h372FFFFBFFFFFFFF; - y = 64'h00200003FDFFFFFF; - zrf = 64'h43474A03BCE98E5F; - ans = 64'h43474A03BCE98E5F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3488747\n"); - end - xrf = 64'h3C5BE00000000000; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3489361\n"); - end - xrf = 64'h8010000000000001; - y = 64'hC0B7FFFFFFFFFFF7; - zrf = 64'h946000000001BFFE; - ans = 64'h946000000001BFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3489975\n"); - end - xrf = 64'h43F3FFFFFFFFDFFE; - y = 64'h0000000000000000; - zrf = 64'hF4D00007FFF7FFFF; - ans = 64'hF4D00007FFF7FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3490589\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'hC03FE00000FFFFFE; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3491203\n"); - end - xrf = 64'h3FE506CBB5C9EF4A; - y = 64'hC34F7DFFFFFFFFFF; - zrf = 64'h380CC9555D83D483; - ans = 64'hC344B1601A376AED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3491817\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3492431\n"); - end - xrf = 64'hC3DFFFFF80000002; - y = 64'h41C00000002007FF; - zrf = 64'h3FF0000000000000; - ans = 64'hC5AFFFFF80400FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3493045\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h0010000000000000; - zrf = 64'hC1EFFFFFF81FFFFE; - ans = 64'hC1EFFFFFF81FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3493659\n"); - end - xrf = 64'hC00FFFFFE0000003; - y = 64'hC7E0000070000000; - zrf = 64'hBFFFE000000001FF; - ans = 64'h480000005FFFFF92; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3494273\n"); - end - xrf = 64'h4C90FFFC00000000; - y = 64'h0010000000000001; - zrf = 64'h8010000000000000; - ans = 64'h0CB0FFFC00000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3494887\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h434FA2E02353B267; - zrf = 64'hBD91FFFFFFBFFFFF; - ans = 64'hBD91FFFFFFBFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3495501\n"); - end - xrf = 64'h800FFFFFFFBFDFFF; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hC09FFFFFE0000003; - ans = 64'hC09FFFFFE0000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3496115\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h413FFFFDFFFFFF7F; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3496729\n"); - end - xrf = 64'h400FFFFFFE000003; - y = 64'h47E3EFFFFFFFFFFE; - zrf = 64'hFFD2F1E7ED80838D; - ans = 64'hFFD2F1E7ED80838D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3497343\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h3CA0000000000001; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3497957\n"); - end - xrf = 64'hC2AFFFFFFFFFFFE6; - y = 64'h401FFF8FFFFFFFFF; - zrf = 64'h3FE0000000000001; - ans = 64'hC2DFFF8FFFFFFFC5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3498571\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h3FA0FFFFFFFFFDFF; - ans = 64'h3FA0FFFFFFFFFDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3499185\n"); - end - xrf = 64'hDED45D2D699E6FBD; - y = 64'h3F9FFFE0001FFFFE; - zrf = 64'h3C0FFFFEFFFFFFF6; - ans = 64'hDE845D190C85634B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3499799\n"); - end - xrf = 64'h3F9FFFEFFFFFFFFF; - y = 64'h3FD0000000000000; - zrf = 64'h8000000000000001; - ans = 64'h3F7FFFEFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3500413\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'hC5D0010FFFFFFFFE; - zrf = 64'hC1C007FEFFFFFFFF; - ans = 64'hC1C007FEFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3501027\n"); - end - xrf = 64'hC7EFFFFFFFFFFFAF; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h43DFFFF7FFFFFFFD; - ans = 64'hC7DFFFFFFFFFFFAE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3501641\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h3FDFFFE000000000; - zrf = 64'hC010000000000001; - ans = 64'hC010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3502255\n"); - end - xrf = 64'h43C000001FFF7FFF; - y = 64'hC0AFFFFFF0000040; - zrf = 64'h3FCAC386871DE4A6; - ans = 64'hC480000017FF800F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3502869\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h3FE0000000000000; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3503483\n"); - end - xrf = 64'h3EC80743205F2B82; - y = 64'h3FDF00000007FFFF; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FE00002E8E120EC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3504097\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h3FE0000000000001; - zrf = 64'hBFCFF3FFFFFFFFFF; - ans = 64'hBFCFF3FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3504711\n"); - end - xrf = 64'h6D70000007FFFFEF; - y = 64'hC22FFF00003FFFFE; - zrf = 64'h7FD00FFFFFDFFFFF; - ans = 64'h7FD00FFFFFDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3505325\n"); - end - xrf = 64'h3FA000000400FFFF; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3505939\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h3FCF800001FFFFFE; - zrf = 64'hBCA0000FF8000000; - ans = 64'hBCA0000FF8000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3506553\n"); - end - xrf = 64'h3970000000200000; - y = 64'h3FF0000000000001; - zrf = 64'h40700000000100FF; - ans = 64'h40700000000100FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3507167\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'hC1FFFFFFFFFFCFFE; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3507781\n"); - end - xrf = 64'hC3FFFFFFFF7FF7FF; - y = 64'h3D5DB9AE86D5D3FA; - zrf = 64'h43D00000000407FF; - ans = 64'h43D000000003CC8C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3508395\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h401FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3509009\n"); - end - xrf = 64'h381000010000003E; - y = 64'h43FFFF000000003F; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h3CB007FFC07FFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3509623\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h4000000000000000; - zrf = 64'h48049FCD56F7E1F9; - ans = 64'h48049FCD56F7E1F9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3510237\n"); - end - xrf = 64'h0010000400000400; - y = 64'hC80FE00000003FFE; - zrf = 64'h43D0000000001FFF; - ans = 64'h43D0000000001FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3510851\n"); - end - xrf = 64'h3649AFC65D0A6F1A; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3511465\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h4024A534AC48D6E4; - zrf = 64'h3E7FFFFFFF7FE000; - ans = 64'h3E7FFFFFFF7FE000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3512079\n"); - end - xrf = 64'hBFEFFFFFFFFF7FDE; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hC7EFFBFFFFFFFFEE; - ans = 64'hC7EFFBFFFFFFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3512693\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h0020C022F6C81829; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hBFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3513307\n"); - end - xrf = 64'hBD5FFFFFC0000040; - y = 64'hFFD0000037FFFFFF; - zrf = 64'hB7FFFF0000003FFF; - ans = 64'h7D40000017FFFFAF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3513921\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3514535\n"); - end - xrf = 64'h0020800000000040; - y = 64'h855FFFFC00800000; - zrf = 64'h3CA0000000000000; - ans = 64'h3CA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3515149\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h7FDEF537F9C2304D; - ans = 64'h7FDEF537F9C2304D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3515763\n"); - end - xrf = 64'h402FFFFFFFBFFDFF; - y = 64'h380E71F983F5560D; - zrf = 64'h40107FF7FFFFFFFF; - ans = 64'h40107FF7FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3516377\n"); - end - xrf = 64'h38022398FCD2938A; - y = 64'h4340000000000001; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3516991\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h4063FFFFFF7FFFFF; - zrf = 64'hC34E00000000001F; - ans = 64'hC34E00000000001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3517605\n"); - end - xrf = 64'h6900040FFFFFFFFF; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h3CA0000820000000; - ans = 64'h6C60040FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3518219\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'hBF40008200000000; - zrf = 64'hBFF0000000000000; - ans = 64'hBFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3518833\n"); - end - xrf = 64'hE86000003FFFFFF7; - y = 64'hBFCFFFFFFFF003FE; - zrf = 64'hBF8FFFFEFFDFFFFE; - ans = 64'h684000003FF801F6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3519447\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h7FE0000000000001; - zrf = 64'h4000000000000000; - ans = 64'hC000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3520061\n"); - end - xrf = 64'h3CA3B66E73907425; - y = 64'hC347B0AB22B11B1E; - zrf = 64'h0010000000000001; - ans = 64'hBFFD2FE85D912D4F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3520675\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hC1FFFFBBFFFFFFFF; - ans = 64'hC1FFFFBC007FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3521289\n"); - end - xrf = 64'hC7E00000000003EF; - y = 64'hC0DFFFFFFFBFE000; - zrf = 64'h41EFFFFFFE03FFFF; - ans = 64'h48CFFFFFFFBFE7DE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3521903\n"); - end - xrf = 64'hD8BEFFFFF7FFFFFF; - y = 64'h7FF0000000000000; - zrf = 64'h4340000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3522517\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h40300000003FEFFF; - zrf = 64'h3EC007DFFFFFFFFF; - ans = 64'h3EC007DFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3523131\n"); - end - xrf = 64'h38DFFFFBFFFFFDFE; - y = 64'h7FF0000000000001; - zrf = 64'hC3FE5E4374175B59; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3523745\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h403FFFFEFDFFFFFF; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3524359\n"); - end - xrf = 64'h403FFFFFEFEFFFFE; - y = 64'hBB2000080007FFFE; - zrf = 64'hBE2C76A7686DFB50; - ans = 64'hBE2C76A7686DFD50; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3524973\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h8000000000000000; - zrf = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3525587\n"); - end - xrf = 64'h4104000000FFFFFF; - y = 64'hC3C3FFFFFFFFFBFF; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hC4D90000013FFAFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3526201\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h8000000000000001; - zrf = 64'hC800000000001FFE; - ans = 64'hC800000000001FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3526815\n"); - end - xrf = 64'hBCA3FFFFFF7FFFFE; - y = 64'h7CFFFFFFFFFFFF86; - zrf = 64'hC7E0000008007FFF; - ans = 64'hF9B3FFFFFF7FFFB2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3527429\n"); - end - xrf = 64'h4050000000081FFF; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h401FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3528043\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'hC27F800000080000; - zrf = 64'h400FFF000FFFFFFE; - ans = 64'h400FFF000FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3528657\n"); - end - xrf = 64'h3CA0000400000800; - y = 64'h8010000000000000; - zrf = 64'h41F0900000000000; - ans = 64'h41F0900000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3529271\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h3E57FFFFFFFFF7FE; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3529885\n"); - end - xrf = 64'hBFFFFFFFFFFFF7FE; - y = 64'hBFD00000021FFFFF; - zrf = 64'hC1CFFFBEFFFFFFFF; - ans = 64'hC1CFFFBEFFBFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3530499\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3531113\n"); - end - xrf = 64'h40CFFFFFFE00003F; - y = 64'h3EAFBFFFFFFFFFF0; - zrf = 64'hFFFFFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -270355,19 +74457,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -270383,952 +74485,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3531727\n"); + $fwrite(fp,"3190175\n"); end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'hBCA0000000000000; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3532341\n"); - end - xrf = 64'h40D003FFBFFFFFFF; - y = 64'hC0196164645A61E5; - zrf = 64'h402B42415A9A50D4; - ans = 64'hC0F966E245E31218; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3532955\n"); - end - xrf = 64'h41DD5E1041ECA9F1; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h400FFFFFC543DF7A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3533569\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'hC780000006FFFFFF; - zrf = 64'h82E3CEE5E282FCA6; - ans = 64'h07B0000006FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3534183\n"); - end - xrf = 64'h400FFFFF800FFFFF; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h43FFC00000000007; - ans = 64'h43FFC00000000007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3534797\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h403FFFFC00000080; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hBCAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3535411\n"); - end - xrf = 64'hE53FF80000008000; - y = 64'h40327D016FBE9017; - zrf = 64'h49194977C779FC34; - ans = 64'hE58278622F62EA67; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3536025\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3536639\n"); - end - xrf = 64'hC1CFFFE000000001; - y = 64'h43F9C62BF671BF1C; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3537253\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h0000000000021FFF; - ans = 64'h0010000000021FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3537867\n"); - end - xrf = 64'hC3D080003FFFFFFE; - y = 64'h7FFFFFFFFFFBF7FF; - zrf = 64'hC0BFF7FFFFFFFFFF; - ans = 64'h7FFFFFFFFFFBF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3538481\n"); - end - xrf = 64'h402FF00000FFFFFF; - y = 64'hBFE0000000000001; - zrf = 64'h4000000000000000; - ans = 64'hC017F00001000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3539095\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h3E2000000008001E; - zrf = 64'hC623ABA49F8E6A01; - ans = 64'hC623ABA49F8E6A01; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3539709\n"); - end - xrf = 64'h41D000007FFFFFEF; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h385FFF8000FFFFFE; - ans = 64'hC1D000007FFFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3540323\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h43E03FFFFFC00000; - zrf = 64'hBCA0000000000000; - ans = 64'hBCA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3540937\n"); - end - xrf = 64'hB890000000000203; - y = 64'hBFFBFC0000000000; - zrf = 64'hDFB98E7EA50A7F54; - ans = 64'hDFB98E7EA50A7F54; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3541551\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'hBFF0000000000001; - zrf = 64'h3FD0000000000000; - ans = 64'h3FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3542165\n"); - end - xrf = 64'hB8001FFFFFFFFFDF; - y = 64'h3E03C923713BC58E; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3542779\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'hC1D000000080007F; - ans = 64'hC1D000000080007F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3543393\n"); - end - xrf = 64'hBFDAE20492ABEECE; - y = 64'h000FFFFFFFE0001F; - zrf = 64'hC00C81C068E036FB; - ans = 64'hC00C81C068E036FB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3544007\n"); - end - xrf = 64'hC02E97087858051B; + x = 64'h439FFDFFFF7FFFFF; y = 64'hC000000000000000; - zrf = 64'h3FF0000000000001; - ans = 64'h403F97087858051B; + z = 64'hBFC00000001FEFFF; + ans = 64'hC3AFFDFFFF7FFFFF; rn = 1; rz = 0; rm = 0; @@ -271342,19 +74504,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -271370,12 +74532,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3544621\n"); + $fwrite(fp,"3192189\n"); end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h3FEEFFFFFFF7FFFE; - zrf = 64'h3977FFFFF8000000; - ans = 64'h3977FFFFF8000000; + x = 64'hBFBFFFFFFFFB7FFF; + y = 64'h40AFFFFFEF000000; + z = 64'h3FD000000000FE00; + ans = 64'hC07FFBFFEEFB7FC0; rn = 1; rz = 0; rm = 0; @@ -271389,19 +74551,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -271417,3583 +74579,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3545235\n"); + $fwrite(fp,"3194203\n"); end - xrf = 64'h841489E493F1E3FB; - y = 64'hC000000000000001; - zrf = 64'hB7FFFFFFF1FFFFFF; - ans = 64'hB7FFFFFFF1FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3545849\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'hA4780952CC27292A; - zrf = 64'h8010000000000001; - ans = 64'h8010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3546463\n"); - end - xrf = 64'h3C60000000FFFFF7; - y = 64'hC000000003FF7FFF; - zrf = 64'hC0140001FFFFFFFF; - ans = 64'hC0140001FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3547077\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'hC010000000000000; - zrf = 64'h3CA0000000000001; - ans = 64'h3CA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3547691\n"); - end - xrf = 64'hB81FFFBFFBFFFFFF; - y = 64'h41DFFE0001FFFFFF; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3548305\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; + x = 64'h8000000000000001; y = 64'hC010000000000001; - zrf = 64'hC1C000080000007F; - ans = 64'hC1C000080000007F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3548919\n"); - end - xrf = 64'h400007FFF0000000; - y = 64'h401FE00000000003; - zrf = 64'h3FB0000000001080; - ans = 64'h403007F7F0100012; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3549533\n"); - end - xrf = 64'h3FF3FFFFFFFFFFFD; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'hC021FFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3550147\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'hC01FFFFFE003FFFF; - zrf = 64'h3FC08A330A869AF2; - ans = 64'h3FC08A330A869AF2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3550761\n"); - end - xrf = 64'h41DB6C4ECDBC587A; - y = 64'hC340000000000000; - zrf = 64'h3FDA48692615FFD5; - ans = 64'hC52B6C4ECDBC587A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3551375\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'hC5E0000001000000; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h0610000000FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3551989\n"); - end - xrf = 64'hF1FF80000000000E; - y = 64'hC3C0008000000001; - zrf = 64'hB6FFFFFBFFFFFFDF; - ans = 64'h75CF80FC00000010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3552603\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h037FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3553217\n"); - end - xrf = 64'h8000002FFFFFFFFF; - y = 64'h56C3FFFEFFFFFFFF; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3553831\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'hFFE0000000000000; - zrf = 64'hFFE52EC42BD5246C; - ans = 64'hFFE52EC42BD5246C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3554445\n"); - end - xrf = 64'h3AE000A000000000; - y = 64'hBFC9DD9C9FA6F045; - zrf = 64'hAC4FFFFFF800001E; - ans = 64'hBAB9DE9F47C52CCA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3555059\n"); - end - xrf = 64'hB8000010000001FF; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h78000010000001FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3555673\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'hC03FFFDFFFEFFFFF; - zrf = 64'hD8CFEFFFFDFFFFFE; - ans = 64'hD8CFEFFFFDFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3556287\n"); - end - xrf = 64'h4F1FFEFFEFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'hC03FFFFFC0000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3556901\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'h38100000007BFFFE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3557515\n"); - end - xrf = 64'hBFBA38B46A6BC45C; - y = 64'hB5700001FFEFFFFF; - zrf = 64'h0010000400001FFE; - ans = 64'h353A38B7B16818F3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3558129\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3558743\n"); - end - xrf = 64'hC1FFFFFFFFFF000F; - y = 64'h401FF0000007FFFF; - zrf = 64'hC010000000000000; - ans = 64'hC22FF000000F008E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3559357\n"); - end - xrf = 64'h801FFFFFFFFFFFFF; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'hC1E0EEDC0A56584A; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3559971\n"); - end - xrf = 64'hC3E0000000DFFFFF; - y = 64'hBFB004000001FFFF; - zrf = 64'h401EFDFFFFFFFFFF; - ans = 64'h43A0040000E237FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3560585\n"); - end - xrf = 64'h3BDFFFFFFFFFFFFF; - y = 64'h0000000000000001; - zrf = 64'h3FD0000000000000; - ans = 64'h3FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3561199\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h3F10000010040000; - zrf = 64'hB80000000203FFFF; - ans = 64'hB80000000203FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3561813\n"); - end - xrf = 64'hC756C2BB148137AE; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h47F1999FB520B400; - ans = 64'h47F1999FB520B400; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3562427\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hFFDFFF00000007FF; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3563041\n"); - end - xrf = 64'h3CAFFDFFFFFDFFFE; - y = 64'hC05FE0000000FFFF; - zrf = 64'hBFBFFBFFFEFFFFFE; - ans = 64'hBFBFFBFFFF0007F6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3563655\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h0010000000000001; - zrf = 64'h0000000000000000; - ans = 64'h8000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3564269\n"); - end - xrf = 64'hA589D73A50255699; - y = 64'hBFBDFFFFFFFFFFEF; - zrf = 64'hC000000000000001; - ans = 64'hC000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3564883\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hB80000000000103F; - ans = 64'hB80000000000103F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3565497\n"); - end - xrf = 64'h599A418CB6682652; - y = 64'h38185008F1338C4A; - zrf = 64'hFFD1FFFFFFFFFBFE; - ans = 64'hFFD1FFFFFFFFFBFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3566111\n"); - end - xrf = 64'h401676FE6363B6AF; - y = 64'h3CA0000000000000; - zrf = 64'h3CA0000000000001; - ans = 64'h3CCA76FE6363B6AF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3566725\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h40066A7122CE9B43; - zrf = 64'hBFFFFFBFFFFBFFFE; - ans = 64'hBFFFFFBFFFFBFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3567339\n"); - end - xrf = 64'hB80D7AECC874C39B; - y = 64'h3CA0000000000001; - zrf = 64'h37E000080001FFFF; - ans = 64'h37E000080001FFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3567953\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h37F0000007FFE000; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3568567\n"); - end - xrf = 64'h5800000007FFFEFF; - y = 64'h47F3EFFFFFFFFFFE; - zrf = 64'h251000040000003E; - ans = 64'h6003F00009F7FEBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3569181\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3569795\n"); - end - xrf = 64'hC1E0000001FDFFFF; - y = 64'hC61EFFFFFFFFFFFB; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'h480F000003DC1FF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3570409\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h3FD0000000000001; - zrf = 64'hD75001FFFFFFF7FE; - ans = 64'hD75001FFFFFFF7FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3571023\n"); - end - xrf = 64'hB4500A9B355B9DA1; - y = 64'h434FDFFFFFFFFF00; - zrf = 64'h802A66CCDA332D0A; - ans = 64'hB7AFF521344C8306; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3571637\n"); - end - xrf = 64'h47FFFFFFFFFFE000; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h47EFFFFFFFFFDFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3572251\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hC3F00000FBFFFFFF; - zrf = 64'hC020008000080000; - ans = 64'hC020008000080000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3572865\n"); - end - xrf = 64'h40C00E9357F1C66A; - y = 64'h3FE0000000000000; - zrf = 64'h840000000008007F; - ans = 64'h40B00E9357F1C66A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3573479\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hBFC01BFFFFFFFFFE; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3574093\n"); - end - xrf = 64'h4019103C1A2007AE; - y = 64'hC1E000000001DFFE; - zrf = 64'h7FEFFFFFFEDFFFFF; - ans = 64'h7FEFFFFFFEDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3574707\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3575321\n"); - end - xrf = 64'hC010003FFDFFFFFE; - y = 64'h380F7FFFFFFFE000; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hBFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3575935\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h3FF0000000000000; - zrf = 64'hFFEB2A3DD30E39A1; - ans = 64'hFFEB2A3DD30E39A1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3576549\n"); - end - xrf = 64'h3FFFFFE003FFFFFF; - y = 64'h43E5002C3E9728BF; - zrf = 64'hC1CFE0000001FFFE; - ans = 64'h43F500174106F3AF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3577163\n"); - end - xrf = 64'hBFD000007FFF7FFE; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'hBFE000007FFF7FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3577777\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h3FD0000004FFFFFF; - zrf = 64'h37ED063ED7FADEC0; - ans = 64'h37ED063ED7FADEC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3578391\n"); - end - xrf = 64'hBFDFFDFFFFFFDFFF; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hC347ACB97EB17C3A; - ans = 64'hC347ACB97EB17C3A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3579005\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h40F00000007FBFFF; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h401FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3579619\n"); - end - xrf = 64'hC1C00000017FFFFF; - y = 64'hC0301EFFFFFFFFFE; - zrf = 64'hC4AFFFFBFFFFFFFD; - ans = 64'hC4AFFFFBFFFFFBF5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3580233\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h4000000000000001; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3580847\n"); - end - xrf = 64'hB6DFFB8000000000; - y = 64'hC05FFFFFFFFDFFC0; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3581461\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h4010002000000003; - ans = 64'h4010002000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3582075\n"); - end - xrf = 64'hB7E0000000802000; - y = 64'hCB5007FFFFFFF800; - zrf = 64'h409FFFDFFFFBFFFF; - ans = 64'h4340080000805C10; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3582689\n"); - end - xrf = 64'h3FE00000001FFFFD; - y = 64'h4010000000000001; - zrf = 64'h0000000000000000; - ans = 64'h40000000001FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3583303\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h37EFF00004000000; - zrf = 64'hC80001003FFFFFFE; - ans = 64'hC80001003FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3583917\n"); - end - xrf = 64'hC007800000000000; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hC1CB8195F37757A9; - ans = 64'hC1CB8195FF3757A9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3584531\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h4010B67191C48B15; - zrf = 64'h4010000000000000; - ans = 64'h4010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3585145\n"); - end - xrf = 64'h3835086F8A7930D6; - y = 64'h400F7BFFFFFFFFFF; - zrf = 64'h45AFFFFFFFFFFDFF; - ans = 64'h45AFFFFFFFFFFDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3585759\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h4340000000000000; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3586373\n"); - end - xrf = 64'hCEF000000207FFFF; - y = 64'hC05CDD77E0D1432A; - zrf = 64'hBFD0000000000001; - ans = 64'h4F5CDD77E47B60E0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3586987\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h403BFFFFFFFFFFBE; - ans = 64'h403BFFFFFFFFFFBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3587601\n"); - end - xrf = 64'hB81E7FFFFFFFFFFF; - y = 64'h4D410000FFFFFFFE; - zrf = 64'hC3EFFFFFFF7FF7FF; - ans = 64'hC570340103FFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3588215\n"); - end - xrf = 64'h1FE0FFBFFFFFFFFF; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3588829\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hC3CFFFE000007FFF; - ans = 64'hC3CFFFE000007FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3589443\n"); - end - xrf = 64'hBFC391E68E64E4C7; - y = 64'h7FE0000000000001; - zrf = 64'h28E07F7FFFFFFFFE; - ans = 64'hFFB391E68E64E4C8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3590057\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h3FE11F532437EC3E; - zrf = 64'h4000000000000001; - ans = 64'h4000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3590671\n"); - end - xrf = 64'h44A0000023FFFFFF; - y = 64'hC3C0010000080000; - zrf = 64'h8019FFFFFFFFFFFF; - ans = 64'hC8700100240A3FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3591285\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hC010000000000001; - ans = 64'hC027FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3591899\n"); - end - xrf = 64'h402FFFFFFFFFFFEC; - y = 64'h380FFFFE00FFFFFF; - zrf = 64'hBCAFFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; ans = 64'hBCAFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -275008,19 +74598,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -275036,12 +74626,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3592513\n"); + $fwrite(fp,"3196217\n"); end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h7FF0000000000001; - zrf = 64'h46E0000021000000; - ans = 64'h7FF8000000000001; + x = 64'hCBEFF5E54070F06F; + y = 64'hC340000000000000; + z = 64'h41A0000000001FFD; + ans = 64'h4F3FF5E54070F06F; rn = 1; rz = 0; rm = 0; @@ -275055,19 +74645,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -275083,12 +74673,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3593127\n"); + $fwrite(fp,"3198231\n"); end - xrf = 64'h4020000100000000; - y = 64'h3D4FB80000000000; - zrf = 64'h38007FFFFFFFF7FF; - ans = 64'h3D7FB801FB800000; + x = 64'hE24FFFFFFFF7FFFB; + y = 64'hA70FFFEF7FFFFFFF; + z = 64'hC34FFFFFFE00001F; + ans = 64'h496FFFEF7FF7FFFE; rn = 1; rz = 0; rm = 0; @@ -275102,19 +74692,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -275130,12 +74720,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3593741\n"); + $fwrite(fp,"3200245\n"); end - xrf = 64'h43D017FFFFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; + x = 64'h8000000000000001; + y = 64'hFFE0000000000001; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000003; rn = 1; rz = 0; rm = 0; @@ -275149,19 +74739,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -275177,12 +74767,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3594355\n"); + $fwrite(fp,"3202259\n"); end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hC0500003FFE00000; - zrf = 64'h448357C41790A530; - ans = 64'h448357C41790A530; + x = 64'h41E0210000000000; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h401FFFFF9FFFFFFE; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -275196,19 +74786,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -275224,12 +74814,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3594969\n"); + $fwrite(fp,"3204273\n"); end - xrf = 64'h7FCCADFDE13D2A89; - y = 64'h8000000000000000; - zrf = 64'hC00EFFFFFFFEFFFF; - ans = 64'hC00EFFFFFFFEFFFF; + x = 64'h43FFFFFFFFF7FFBF; + y = 64'h40107FFFFFFFBFFF; + z = 64'hC01000002000007E; + ans = 64'h44207FFFFFFB9FDD; rn = 1; rz = 0; rm = 0; @@ -275243,19 +74833,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -275271,12 +74861,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3595583\n"); + $fwrite(fp,"3206287\n"); end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h3C6F000000000FFF; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFF; + x = 64'h800FFFFFFFFFFFFF; + y = 64'h0000000000000000; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; rn = 1; rz = 0; rm = 0; @@ -275290,19 +74880,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -275318,12 +74908,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3596197\n"); + $fwrite(fp,"3208301\n"); end - xrf = 64'hB816C47C77CD4FB9; - y = 64'h3CA0000000001001; - zrf = 64'h43FFFFFFFDFFFEFF; - ans = 64'h43FFFFFFFDFFFEFF; + x = 64'h41E3A0AE429A2C7A; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hBFA0000007FFFFBF; + ans = 64'hBFA0000007FFFFBF; rn = 1; rz = 0; rm = 0; @@ -275337,19 +74927,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -275365,12 +74955,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3596811\n"); + $fwrite(fp,"3210315\n"); end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFF; + x = 64'h41CE90F78950EFF5; + y = 64'h2BC0002001FFFFFF; + z = 64'h47F72050F7B5B781; + ans = 64'h47F72050F7B5B781; rn = 1; rz = 0; rm = 0; @@ -275384,19 +74974,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -275412,12 +75002,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3597425\n"); + $fwrite(fp,"3212329\n"); end - xrf = 64'hB7F00005FFFFFFFF; - y = 64'h7FFFFFFFFFE0007F; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFE0007F; + x = 64'h800FFFFFFFFFFFFF; + y = 64'h3CA0000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -275431,19 +75021,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -275459,12 +75049,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3598039\n"); + $fwrite(fp,"3214343\n"); end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h8010000000000000; - zrf = 64'hBFC0000000000000; - ans = 64'hBFC0000000000000; + x = 64'h00100000013FFFFE; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h43E5EB9A245CBACD; + ans = 64'h43E5EB9A245CBACD; rn = 1; rz = 0; rm = 0; @@ -275478,19 +75068,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -275506,12 +75096,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3598653\n"); + $fwrite(fp,"3216357\n"); end - xrf = 64'h1B400000000FFF7F; - y = 64'h3CAFFFFFFC00FFFE; - zrf = 64'hB80FFFFEFFFFFF7F; - ans = 64'hB80FFFFEFFFFFF7F; + x = 64'hBFBFFFF7FFFFFFFF; + y = 64'hFFFFE00000010000; + z = 64'h245FFFBFFFFFE000; + ans = 64'hFFFFE00000010000; rn = 1; rz = 0; rm = 0; @@ -275525,19 +75115,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -275553,1421 +75143,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3599267\n"); + $fwrite(fp,"3218371\n"); end - xrf = 64'hC3DC5B44CF32758F; - y = 64'h8010000000000001; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3599881\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hC03141D1BA830FA0; - zrf = 64'h432FFC0000010000; - ans = 64'h432FFC0000010000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3600495\n"); - end - xrf = 64'hC7FFFDFFEFFFFFFF; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h41DFFFFDFDFFFFFF; - ans = 64'h41DFFFFDFDFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3601109\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h41CFFFFFE000001E; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h3FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3601723\n"); - end - xrf = 64'h37EFFFFFFFFFFBFF; - y = 64'h37EFFFDFFFFF7FFE; - zrf = 64'h43E0000000008040; - ans = 64'h43E0000000008040; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3602337\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hBCA0000000000001; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hBFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3602951\n"); - end - xrf = 64'hBA5FFFFFF00007FE; - y = 64'h401100007FFFFFFF; - zrf = 64'h8010000000000000; - ans = 64'hBA810000778003FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3603565\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hFFFF9F277AF39F4A; - ans = 64'hFFFF9F277AF39F4A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3604179\n"); - end - xrf = 64'h4340018000000000; - y = 64'h3FB01B3E7CDC5A25; - zrf = 64'h43FD6361F6FE7D6F; - ans = 64'h43FD6382308092DF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3604793\n"); - end - xrf = 64'hC3DFFFFFFFFFEFDF; - y = 64'hBFD0000000000000; - zrf = 64'hC340000000000000; - ans = 64'h43BFDFFFFFFFEFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3605407\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hBFCF0A649CE7E379; - zrf = 64'hBFE07F0000000000; - ans = 64'hBFE07F0000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3606021\n"); - end - xrf = 64'hB7F012DE7CF1AB19; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h47F000003FFFFF7F; - ans = 64'h47F000003FFFFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3606635\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hFCA0000FBFFFFFFE; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE0000000000008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3607249\n"); - end - xrf = 64'hBFB6A48CB024F7A8; - y = 64'hC030000040100000; - zrf = 64'h52F88B314F472C55; - ans = 64'h52F88B314F472C55; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3607863\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hBFE0000000000000; - zrf = 64'hBFF0000000000000; - ans = 64'hBFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3608477\n"); - end - xrf = 64'hCE7FFFEBFFFFFFFF; - y = 64'hBCAC4284F9FA3266; - zrf = 64'h8000000000000001; - ans = 64'h4B3C427350671629; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3609091\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hC03FFFFFFFFF1000; - ans = 64'hC03FFFFFFFFF1000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3609705\n"); - end - xrf = 64'h4006C48B197B2BCB; - y = 64'h43DFF7FFFFFFBFFF; - zrf = 64'h92623F346F64078A; - ans = 64'h43F6BED9F6B49F76; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3610319\n"); - end - xrf = 64'h3EE00000000BFFFE; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hC010000000000001; - ans = 64'hC010000200000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3610933\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h402FFFFEFFFFF7FF; - zrf = 64'hC1FFFEFFFFFFF800; - ans = 64'hC1FFFEFFFFFFF800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3611547\n"); - end - xrf = 64'hC0389D70C7422759; - y = 64'hBFF0000000000001; - zrf = 64'hC1E0001FFFFFFFFE; - ans = 64'hC1E0001FFCEC51E5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3612161\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h43FFFFEFFDFFFFFF; - zrf = 64'h3FD0000000000001; - ans = 64'h3FD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3612775\n"); - end - xrf = 64'h3FE8EEBA01E48447; - y = 64'hC2BFFFFFF800007F; - zrf = 64'h424AC7A4E57541D9; - ans = 64'hC2B8B92AB1DDEBA6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3613389\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3614003\n"); - end - xrf = 64'hC01FFFC00000007E; - y = 64'hC1FFDFFFBFFFFFFF; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3614617\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hC000000000000001; - zrf = 64'hB7F9DEF92C81623D; - ans = 64'hB7F9DEF92C81623D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3615231\n"); - end - xrf = 64'h401FFFFFFFDE0000; - y = 64'h43C0000000007FFC; - zrf = 64'hC1D1FFFFFFFFFFFB; - ans = 64'h43EFFFFFFFD5FFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3615845\n"); - end - xrf = 64'h2D50000000FFFFBE; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3616459\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hCA7FBFFFFFFF7FFF; - zrf = 64'h0010000000002000; - ans = 64'h0AAFBFFFFFFF7FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3617073\n"); - end - xrf = 64'hC0607FFBFFFFFFFF; - y = 64'hC010000000000000; - zrf = 64'h3FFFFFCFFFFFFFFE; - ans = 64'h40808FFBE7FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3617687\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h43DFFFE003FFFFFF; - zrf = 64'h3CAFFFFFFFFFFFFF; + x = 64'h800FFFFFFFFFFFFF; + y = 64'h3FE0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; ans = 64'h3CAFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -276982,19 +75162,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -277010,12 +75190,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3618301\n"); + $fwrite(fp,"3220385\n"); end - xrf = 64'h4590000007FF7FFF; - y = 64'hC1C86A12F7EE0253; - zrf = 64'h43C10000007FFFFF; - ans = 64'hC7686A130422487D; + x = 64'hC090003FFFFFFFFB; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h41D00000003FFE00; + ans = 64'h41CFFFFE0077FC00; rn = 1; rz = 0; rm = 0; @@ -277029,19 +75209,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -277057,12 +75237,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3618915\n"); + $fwrite(fp,"3222399\n"); end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFDFFFFFFFFFFFFF; + x = 64'hBFFFFFFFFFFFFFFF; + y = 64'h5BB0000000FFFFF6; + z = 64'hFFD4FC49106C175B; + ans = 64'hFFD4FC49106C175B; rn = 1; rz = 0; rm = 0; @@ -277076,19 +75256,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -277104,2174 +75284,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3619529\n"); + $fwrite(fp,"3224413\n"); end - xrf = 64'h402D80C8C9A07C22; - y = 64'h3FD001FFFC000000; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3620143\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hC340000000000000; - zrf = 64'h0F9FFFFFFF000010; - ans = 64'h0F9FFFFFFF000010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3620757\n"); - end - xrf = 64'hBCAFFF80FFFFFFFF; - y = 64'hF4540CFEF492C4F9; - zrf = 64'h43DFFFDFF7FFFFFE; - ans = 64'h71140CAF60FEEA52; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3621371\n"); - end - xrf = 64'hC8076B4F59C23E85; - y = 64'hC340000000000001; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'h4B576B4F59C23E86; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3621985\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hCA30000000000080; - zrf = 64'h3FCDFFFFFFFFFFFC; - ans = 64'h3FCDFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3622599\n"); - end - xrf = 64'hC0E18338554B04B7; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h3EEFFFFFFEFDFFFF; - ans = 64'h44418338554B04B6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3623213\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hDC7FFFFC3FFFFFFE; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h1CAFFFFC3FFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3623827\n"); - end - xrf = 64'h3D25024D4C68C3B0; - y = 64'h3F4FFFFFC00007FF; - zrf = 64'hBF260C1D68A1C2F7; - ans = 64'hBF260C1D68A1BDB6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3624441\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hFFE0000000000001; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3625055\n"); - end - xrf = 64'h299FFFFFFFFFFA00; - y = 64'h241FFFFFFDFFFFF7; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3625669\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h381FFFFFDBFFFFFF; - ans = 64'h401FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3626283\n"); - end - xrf = 64'h3C03D19D713896A0; - y = 64'h43D0000001FFF7FF; - zrf = 64'h40FFDFFFFFFFBFFF; - ans = 64'h40FFE009E8CE79D8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3626897\n"); - end - xrf = 64'h755077FFFFFFFFFE; - y = 64'hFFF0000000000000; - zrf = 64'hBFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3627511\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'h55F901489896FD56; - zrf = 64'h3FC8AE7AC3754886; - ans = 64'h3FC8AE7AC3754886; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3628125\n"); - end - xrf = 64'h3EAFFFFFDFF00000; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hBFFFFFFBFFFFFFFC; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3628739\n"); - end - xrf = 64'h801FFFFFFFFFFFFE; - y = 64'hB5E0010200000000; - zrf = 64'h0010000000000000; - ans = 64'h0010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3629353\n"); - end - xrf = 64'hC0DFFFFF80000001; - y = 64'h44CFFFFFFFF6FFFF; - zrf = 64'hC02FF25C504A2810; - ans = 64'hC5BFFFFF7FF70000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3629967\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h0000000000000000; - zrf = 64'hBCA0000000000000; - ans = 64'hBCA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3630581\n"); - end - xrf = 64'hBE2FFE0000000008; - y = 64'h43DFFFFFFFFF7FFE; - zrf = 64'h4340000000000001; - ans = 64'h433FFFF800800002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3631195\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h7FDFFFFFFFEFFFFC; - ans = 64'h7FDFFFFFFFEFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3631809\n"); - end - xrf = 64'h4FCFE00000000002; - y = 64'hB7F000000000103F; - zrf = 64'hB8089029A0EB5FB8; - ans = 64'hC7CFE00000002060; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3632423\n"); - end - xrf = 64'h402000007FFFFEFF; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3633037\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hBFEFFFFFFFC00010; - zrf = 64'h332FFFFFFFFC07FF; - ans = 64'h3C9FFFFFFFC00010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3633651\n"); - end - xrf = 64'hC032000000000003; - y = 64'h0010000000000001; - zrf = 64'hBE5003FFFFFDFFFE; - ans = 64'hBE5003FFFFFDFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3634265\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h3FF000000FFFFFF7; - zrf = 64'h0000000000000001; - ans = 64'hBCA000000FFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3634879\n"); - end - xrf = 64'hC01FFFF800000200; - y = 64'h401001FFFF7FFFFF; - zrf = 64'hF210000040FFFFFF; - ans = 64'hF210000040FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3635493\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h8010000000000001; - ans = 64'h8010000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3636107\n"); - end - xrf = 64'h00000081FFFFFFFF; - y = 64'hC7EFFFFFFF7EFFFF; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h401FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3636721\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h3CA0000000000001; - zrf = 64'hF7A0000080FFFFFE; - ans = 64'hF7A0000080FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3637335\n"); - end - xrf = 64'hC02918C49CF43452; - y = 64'h7FFFFFFFFFFFFEFC; - zrf = 64'h402FFFFFFFE00080; - ans = 64'h7FFFFFFFFFFFFEFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3637949\n"); - end - xrf = 64'h8020000C00000000; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3638563\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hC03FFFE00000001E; - zrf = 64'h41C007FFFFFFDFFE; - ans = 64'h41C007FFFFFFDFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3639177\n"); - end - xrf = 64'hFFF400000000001E; - y = 64'h3FD0000000000000; - zrf = 64'h9749F8042A7828F1; - ans = 64'hFFFC00000000001E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3639791\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h37EFFFFF7FEFFFFF; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3640405\n"); - end - xrf = 64'hBF0000EFFFFFFFFF; - y = 64'hC77FFFFFFFF5FFFE; - zrf = 64'hC2200003F7FFFFFF; - ans = 64'h469000EFFFFAFFB3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3641019\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'hBC8FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3641633\n"); - end - xrf = 64'hC1FFFFFFFF0FFFFE; - y = 64'hB80FFFE0001FFFFF; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3642247\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h3FE0000000000000; - zrf = 64'hBFBFF7FFFF000000; - ans = 64'hBFBFF7FFFF000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3642861\n"); - end - xrf = 64'hBE2D7F50748E2E92; - y = 64'hB3A004000000003E; - zrf = 64'hBDD00000800FFFFF; - ans = 64'hBDD00000800FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3643475\n"); - end - xrf = 64'h401FFFE000000004; - y = 64'h3FE0000000000001; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'h400FFFE000000005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3644089\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h47FFFFFC00001FFF; - zrf = 64'hBD77EABF70AF8DAD; - ans = 64'hC4AFFFFC00001FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3644703\n"); - end - xrf = 64'h403FFF8002000000; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h324FFFFFFFF8000E; - ans = 64'h403FFF8001FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3645317\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h3FBFFFFFFFFBBFFE; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3645931\n"); - end - xrf = 64'hEDCFFBFFFFFFFFBF; - y = 64'hC00FC02000000000; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'h6DEFBC27FBFFFFC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3646545\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h3FF0000000000001; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3647159\n"); - end - xrf = 64'h4E80C21A53CEB830; - y = 64'h3FAFFFFFFFDF7FFE; - zrf = 64'h4000000000000000; - ans = 64'h4E40C21A53BDB30C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3647773\n"); - end - xrf = 64'hBCA0000000000000; + x = 64'h800FFFFFFFFFFFFF; y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h403EFFFFFFFFFFFB; - ans = 64'h403EFFFFFFFFFFFB; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; rn = 1; rz = 0; rm = 0; @@ -279285,19 +75303,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -279313,153 +75331,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3648387\n"); + $fwrite(fp,"3226427\n"); end - xrf = 64'hC0EC000080000000; - y = 64'hFFEFFFFF7FC00000; - zrf = 64'h3CA00000000003FB; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3649001\n"); - end - xrf = 64'hC3FFC0001FFFFFFF; - y = 64'h4000000000000000; - zrf = 64'hBCA0000000000000; - ans = 64'hC40FC0001FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3649615\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h402FFBFFFFFFFFFF; - zrf = 64'hC1D66071D432CFE3; - ans = 64'hC1D66071D432CFE3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3650229\n"); - end - xrf = 64'h3FC0000000100008; + x = 64'h3A7FDEFFFFFFFFFF; y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hC00FFFFFFE000006; - ans = 64'hC00BFFFFFDFC0004; + z = 64'h3E34007FFFFFFFFF; + ans = 64'h3E34007FFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -279473,19 +75350,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -279501,12 +75378,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3650843\n"); + $fwrite(fp,"3228441\n"); end - xrf = 64'hBCA0000000000000; - y = 64'hC3C00007FFFF8000; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; + x = 64'hC0200000000017FF; + y = 64'hC3E07FEFFFFFFFFE; + z = 64'h41637FFFFFFFFFFE; + ans = 64'h44107FF000001B2D; rn = 1; rz = 0; rm = 0; @@ -279520,19 +75397,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -279548,247 +75425,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3651457\n"); + $fwrite(fp,"3230455\n"); end - xrf = 64'h38163F4BCFE61288; - y = 64'h3FDFFFF001FFFFFE; - zrf = 64'hBF5FFF7FFFFFFFFB; - ans = 64'hBF5FFF7FFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3652071\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h4010000000000000; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3652685\n"); - end - xrf = 64'h801FFBFFFFFDFFFE; - y = 64'hBFDBA8444505653F; - zrf = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3653299\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hC00FDFFFFFF00000; - ans = 64'hC00FDFFFFFF00002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3653913\n"); - end - xrf = 64'h7FFF00000000000F; - y = 64'h3FB400000000001F; - zrf = 64'hC03FFFFFFFDFFFF0; - ans = 64'h7FFF00000000000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3654527\n"); - end - xrf = 64'hBFD0080000000020; + x = 64'h800FFFFFFFFFFFFF; y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h8010000000000001; - ans = 64'hC00008000000001F; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; rn = 1; rz = 0; rm = 0; @@ -279802,19 +75444,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -279830,59 +75472,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3655141\n"); + $fwrite(fp,"3232469\n"); end - xrf = 64'hBCA0000000000000; - y = 64'h41E0FFFFFFFFFFFA; - zrf = 64'hBFF26B5D87C2CB8D; - ans = 64'hBFF26B5DCBC2CB8D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3655755\n"); - end - xrf = 64'h43C0020000400000; + x = 64'h3B9FFFFFF4000000; y = 64'h4340000000000001; - zrf = 64'hC34DBA2051ED9A0F; - ans = 64'h4710020000400001; + z = 64'hB9AFF7FFFFFFFEFF; + ans = 64'h3EEFFFFFF4000002; rn = 1; rz = 0; rm = 0; @@ -279896,19 +75491,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -279924,12 +75519,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3656369\n"); + $fwrite(fp,"3234483\n"); end - xrf = 64'hBCA0000000000000; - y = 64'h3FC000FFFFFFFF80; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000001; + x = 64'hC3E40000000001FF; + y = 64'h40F000003FFF8000; + z = 64'h5FC000007FDFFFFE; + ans = 64'h5FC000007FDFFFFE; rn = 1; rz = 0; rm = 0; @@ -279943,19 +75538,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -279971,3207 +75566,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3656983\n"); + $fwrite(fp,"3236497\n"); end - xrf = 64'hBFFFFFE400000000; - y = 64'hBFDBD54407F5B2BC; - zrf = 64'hC02FFFFFFFFDFFF0; - ans = 64'hC02E42AD45285D34; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3657597\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3658211\n"); - end - xrf = 64'h3FB25318C481E7CE; - y = 64'h480B6030B392D965; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h47CF5A64272A6473; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3658825\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h7FE0000000000000; - zrf = 64'h3CA0FFF800000000; - ans = 64'hFC90000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3659439\n"); - end - xrf = 64'hBC207E0000000000; - y = 64'hC021000000001FFF; - zrf = 64'h7FFD3A97BA6B9782; - ans = 64'h7FFD3A97BA6B9782; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3660053\n"); - end - xrf = 64'h3FD00000007FFBFF; + x = 64'h800FFFFFFFFFFFFF; y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h7FD00000007FFBFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3660667\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hC7E000008003FFFF; - zrf = 64'h403645F83349B39B; - ans = 64'h449000008003FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3661281\n"); - end - xrf = 64'hC3EF14FFEB0F3D07; - y = 64'h7FF0000000000000; - zrf = 64'h801AD5E676A26F15; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3661895\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hBFDFE007FFFFFFFF; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3662509\n"); - end - xrf = 64'hBFB45FC3AA5813AC; - y = 64'h37EFFFE000004000; - zrf = 64'hBEC0000007EFFFFE; - ans = 64'hBEC0000007EFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3663123\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3663737\n"); - end - xrf = 64'h000FFFFBFFFFFFBE; - y = 64'h7FEBB7B174CBCB9B; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h400FB7AA86DF6DF5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3664351\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h001639C0ADB56178; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3664965\n"); - end - xrf = 64'h4002EFFA98BD895F; - y = 64'h3FD0000000000FDF; - zrf = 64'hE5D04000000003FF; - ans = 64'hE5D04000000003FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3665579\n"); - end - xrf = 64'hDB1D604C1DB49326; - y = 64'h8000000000000001; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3666193\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hBFFFFFFFFFFE000F; - zrf = 64'hD0D0000000017FFF; - ans = 64'hD0D0000000017FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3666807\n"); - end - xrf = 64'hC010000001F00000; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'hBA469C50554556D4; - ans = 64'hBA469C50554556D4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3667421\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h3F29FEBD6B0F049C; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3668035\n"); - end - xrf = 64'hBFE0FFFFFC000000; - y = 64'hC1C0001FFFDFFFFF; - zrf = 64'h7FD00040000007FF; - ans = 64'h7FD00040000007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3668649\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h8010000000000001; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h401FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3669263\n"); - end - xrf = 64'hC1EC010F446540A4; - y = 64'hBAC6852416F9C589; - zrf = 64'h3FD0000000000000; - ans = 64'h3FD000000000000A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3669877\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'hF7C00000043FFFFE; - ans = 64'hF7C00000043FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3670491\n"); - end - xrf = 64'hC2E2654CDB87DD48; - y = 64'hC02FFFFFFFFE7FFF; - zrf = 64'hB750040000000010; - ans = 64'h4322654CDB870088; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3671105\n"); - end - xrf = 64'h3F7FFFFFFFF0001E; - y = 64'hBCA0000000000000; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3671719\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hC039C87DD7926BBE; - zrf = 64'h41F000041FFFFFFF; - ans = 64'h41F000041FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3672333\n"); - end - xrf = 64'hB80FFFFFFFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h800000000007FBFE; - ans = 64'h34CFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3672947\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hBFE2000000000003; - zrf = 64'hC000000000000000; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3673561\n"); - end - xrf = 64'h4880000000087FFE; - y = 64'hEA400800007FFFFE; - zrf = 64'hC345D14186A8EEB1; - ans = 64'hF2D008000088843C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3674175\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hBFD0000000000000; - zrf = 64'h4010000000000000; - ans = 64'h4010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3674789\n"); - end - xrf = 64'hC00F800001000000; - y = 64'h4000080000000FFF; - zrf = 64'h3CA0000000000001; - ans = 64'hC01F8FC001009F7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3675403\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hBFD0000000000001; - zrf = 64'hBAB000000000FF7E; - ans = 64'h3C7FFFFFFF000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3676017\n"); - end - xrf = 64'h400FE01000000000; - y = 64'hBFEFFFFFDF000000; - zrf = 64'h27F0000000002000; - ans = 64'hC00FE00FDF20EF80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3676631\n"); - end - xrf = 64'h3FB007FFFFFFFFDF; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3677245\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hBA13FDFFFFFFFFFE; - zrf = 64'h000FFFFFFE200000; - ans = 64'h36C3FDFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3677859\n"); - end - xrf = 64'h41D86E890469D30F; - y = 64'hBFE0000000000000; - zrf = 64'hC03205A669DCD5C0; - ans = 64'hC1C86E890D6CA644; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3678473\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h7FDF03FFFFFFFFFE; - zrf = 64'hBFF0000000000001; - ans = 64'hFC8F03FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3679087\n"); - end - xrf = 64'h7FE00077FFFFFFFE; - y = 64'h40E000001000001E; - zrf = 64'hBFD4FFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3679701\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h4000000000000001; - ans = 64'h4000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3680315\n"); - end - xrf = 64'h4800DF1F660F56AF; - y = 64'hDE3FFFFFFFFFB000; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'hE650DF1F660F2C81; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3680929\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hBFF0000000000000; - zrf = 64'h3E59A41A8D3F0D0E; - ans = 64'h3E59A41A8F3F0D0E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3681543\n"); - end - xrf = 64'h31DC2BE698BED132; - y = 64'h3FA0000400000001; - zrf = 64'hC03FFF8001FFFFFF; - ans = 64'hC03FFF8001FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3682157\n"); - end - xrf = 64'hC0A31FC8DABA02AD; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h43500000000004C7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3682771\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h47E943885C8C6553; - zrf = 64'hC1FEE2CEB74B7C2D; - ans = 64'hC49943885C8C6D0C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3683385\n"); - end - xrf = 64'h42C9F7BB6D642AEB; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h7FF01D9CEB412063; - ans = 64'h7FF81D9CEB412063; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3683999\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hBFD12DBE8A52106B; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3684613\n"); - end - xrf = 64'hBFADA801A13F62D4; - y = 64'h402FDFFFFFFFEFFF; - zrf = 64'h43F00001FFFF8000; - ans = 64'h43F00001FFFF8000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3685227\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3685841\n"); - end - xrf = 64'h3FC0000000800080; - y = 64'hC7E0000FFFF00000; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'hC7B0001000700100; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3686455\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h41DFFFFFFF7FFEFF; - ans = 64'h41DFFFFFFF7FFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3687069\n"); - end - xrf = 64'h6CD0010003FFFFFF; - y = 64'hC1E000000FFFFFFF; - zrf = 64'hB5A0003FFFFBFFFF; - ans = 64'hEEC0010014010002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3687683\n"); - end - xrf = 64'hB810FFFFBFFFFFFF; - y = 64'hC010000000000001; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h401FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3688297\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hC3EFC04000000000; - zrf = 64'h43EFFFBFFFFFFF7F; - ans = 64'h43EFFFBFFFFFFF80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3688911\n"); - end - xrf = 64'h99B00008000FFFFE; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hBE4FF80000007FFF; - ans = 64'hBE4FF80000007FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3689525\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hC451238B3FAD72A9; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'h410123873FAD72A9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3690139\n"); - end - xrf = 64'h3FEB03EBAD17DB6E; - y = 64'h434FFFFD7FFFFFFF; - zrf = 64'hC2951E9EDCF540CE; - ans = 64'h434B0145BCEDD33F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3690753\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hC340000000000001; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3691367\n"); - end - xrf = 64'h0005E0458A43FBDB; - y = 64'h7FDFFFBFFFFFFFFF; - zrf = 64'h0000000000000000; - ans = 64'h3FE780E726E39D4B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3691981\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h3FF0000002000003; - ans = 64'h4008000001000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3692595\n"); - end - xrf = 64'h3FF0000000000043; - y = 64'h3FFD92E157246295; - zrf = 64'h00205FFFFFFFFFFF; - ans = 64'h3FFD92E157246311; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3693209\n"); - end - xrf = 64'hC2DFFFFFBFF7FFFF; - y = 64'hFFE0000000000000; - zrf = 64'h4010000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3693823\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h47E02D7CE2B31E42; - zrf = 64'h3FDFFFFEFFFFFFFF; - ans = 64'hC4902D7CE2B31E42; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3694437\n"); - end - xrf = 64'h4AD0000000010400; - y = 64'hFFE0000000000001; - zrf = 64'hC01FFFFFFFFFFB80; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3695051\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'h35A00080FFFFFFFF; - zrf = 64'hBFD0000000000000; - ans = 64'hBFD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3695665\n"); - end - xrf = 64'hBCAFFFFFE00001FF; - y = 64'h3283FE0000000000; - zrf = 64'hC02F7FFFFFFFFEFF; - ans = 64'hC02F7FFFFFFFFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3696279\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hFFF0000000000000; - zrf = 64'h3FE0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3696893\n"); - end - xrf = 64'h43EFFFFDFFFDFFFF; - y = 64'hBFBFFFFFE0000003; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3697507\n"); - end - xrf = 64'hBCA0000000000000; - y = 64'hFFF0000000000001; - zrf = 64'h43DBFFFFFFFFFFF7; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3698121\n"); - end - xrf = 64'h3FC0000203FFFFFE; - y = 64'h4398F59E6CA7D49A; - zrf = 64'hBF9FF3DF6A07BBD1; - ans = 64'h4368F5A1919909C7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3698735\n"); - end - xrf = 64'hFFFFFEFFFFFBFFFE; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h4000000000000001; + z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -283186,19 +75585,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -283214,12 +75613,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3699349\n"); + $fwrite(fp,"3238511\n"); end - xrf = 64'hBCA0000000000001; - y = 64'h001000004000007F; - zrf = 64'h41C007FFFFEFFFFF; - ans = 64'h41C007FFFFEFFFFF; + x = 64'h59300000000083FF; + y = 64'h7FF0000000000001; + z = 64'h3FE000003FFEFFFF; + ans = 64'h7FF8000000000001; rn = 1; rz = 0; rm = 0; @@ -283233,19 +75632,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -283261,12 +75660,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3699963\n"); + $fwrite(fp,"3240525\n"); end - xrf = 64'hAD45032AE4153B5D; - y = 64'h0000000000000000; - zrf = 64'h3FDFFBFFBFFFFFFF; - ans = 64'h3FDFFBFFBFFFFFFF; + x = 64'h43C0000400000007; + y = 64'hBFFFFFFDFFFFFDFF; + z = 64'h401FFFFFFFF81FFE; + ans = 64'hC3D00002FFFFBF06; rn = 1; rz = 0; rm = 0; @@ -283280,19 +75679,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -283308,12 +75707,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3700577\n"); + $fwrite(fp,"3242539\n"); end - xrf = 64'hBCA0000000000001; - y = 64'hC0A0000001FFFFEF; - zrf = 64'hBCA0000000000001; - ans = 64'h3D4FFC0003FFFFE0; + x = 64'h800FFFFFFFFFFFFF; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -283327,19 +75726,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -283355,12 +75754,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3701191\n"); + $fwrite(fp,"3244553\n"); end - xrf = 64'hFFE01FFFDFFFFFFF; - y = 64'hB80007FFFFFFFFF7; - zrf = 64'hBFE4001FFFFFFFFE; - ans = 64'h77F0280FDFEFFFF6; + x = 64'hBFC00000001FFFFF; + y = 64'h8010000000000001; + z = 64'hC08007FFFF7FFFFF; + ans = 64'hC08007FFFF7FFFFF; rn = 1; rz = 0; rm = 0; @@ -283374,19 +75773,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -283402,12 +75801,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3701805\n"); + $fwrite(fp,"3246567\n"); end - xrf = 64'hBCA0000000000001; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h3FD0000000000001; - ans = 64'h3FD0000000000001; + x = 64'h380531927F4EEF39; + y = 64'h2EC0003FFFFFFC00; + z = 64'hBFC7FFFFFFEFFFFF; + ans = 64'hBFC7FFFFFFEFFFFF; rn = 1; rz = 0; rm = 0; @@ -283421,19 +75820,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -283449,12 +75848,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3702419\n"); + $fwrite(fp,"3248581\n"); end - xrf = 64'hC7E00000F7FFFFFF; - y = 64'h3E22A58881822F6B; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; + x = 64'h800FFFFFFFFFFFFF; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; rn = 1; rz = 0; rm = 0; @@ -283468,19 +75867,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -283496,12 +75895,670 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3703033\n"); + $fwrite(fp,"3250595\n"); end - xrf = 64'hBCA0000000000001; + x = 64'hC010000000000FFA; + y = 64'hBFD0000000000000; + z = 64'h3F60000000200002; + ans = 64'h3FF0080000001FFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3252609\n"); + end + x = 64'hC03000000003EFFF; + y = 64'h400FBFFFFFFBFFFF; + z = 64'h704FFFE7FFFFFFFF; + ans = 64'h704FFFE7FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3254623\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hBFE0000000000001; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3256637\n"); + end + x = 64'h3FD00000FFFFFF80; + y = 64'hBFF0000000000000; + z = 64'hBF6000000020FFFF; + ans = 64'hBFD0200100004180; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3258651\n"); + end + x = 64'h3FCFFFFFFFF7FF7F; + y = 64'hBFF4691AA0D59FCD; + z = 64'h40600007FFE00000; + ans = 64'h405FEBA6E51F2F7B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3260665\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hC000000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3262679\n"); + end + x = 64'hBC3A181B260C5619; + y = 64'hC010000000000000; + z = 64'h3816B4ADA3BAD7DB; + ans = 64'h3C5A181B260C5619; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3264693\n"); + end + x = 64'h4010000000000000; + y = 64'hCA32000000008000; + z = 64'h800FFFFFFF00000F; + ans = 64'hCA52000000008000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3266707\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hC340000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3268721\n"); + end + x = 64'hA04FFF7FFFFFFFFE; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'hC0099D723A9AB007; + ans = 64'hC0099D723A9AB007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3270735\n"); + end + x = 64'hFFD03FFFFFFFFFFE; + y = 64'h44A0000000000120; + z = 64'hC08576D5A804F3AE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3272749\n"); + end + x = 64'h800FFFFFFFFFFFFF; + y = 64'hFFF0000000000000; + z = 64'hBFF0000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3274763\n"); + end + x = 64'hBFEFE3FFFFFFFFFF; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hB8048124EE8F2256; + 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,"3276777\n"); + end + x = 64'h3EEFFF0200000000; + y = 64'hC7EA5C98C43C0BC7; + z = 64'hBF8097B90395D8E2; + ans = 64'hC6EA5BC7853F762A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3278791\n"); + end + x = 64'h800FFFFFFFFFFFFE; y = 64'h0010000000000000; - zrf = 64'h05CF952FB7C9E1F0; - ans = 64'h05CF952FB7C9E1F0; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; rn = 1; rz = 0; rm = 0; @@ -283515,19 +76572,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -283543,59 +76600,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3703647\n"); + $fwrite(fp,"3280805\n"); end - xrf = 64'h3FFFFE0000FFFFFF; - y = 64'h35503FFFFFFFFFFE; - zrf = 64'hC020000000300000; - ans = 64'hC020000000300000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3704261\n"); - end - xrf = 64'h47EF01BF46D247DB; + x = 64'hC050000100003FFF; y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFF; + z = 64'h47EFFFC001FFFFFE; + ans = 64'h47EFFFC001FFFFFE; rn = 1; rz = 0; rm = 0; @@ -283609,19 +76619,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -283637,12 +76647,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3704875\n"); + $fwrite(fp,"3282819\n"); end - xrf = 64'hBCA0000000000001; - y = 64'h002BFFFFFFFFFFFB; - zrf = 64'hBFC0000100000002; - ans = 64'hBFC0000100000002; + x = 64'h7560000001FFFFFE; + y = 64'h3FC1E915AABC5C49; + z = 64'hF5DFC0000FFFFFFF; + ans = 64'hF5DFBB85CA94C19F; rn = 1; rz = 0; rm = 0; @@ -283656,19 +76666,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -283684,12 +76694,1563 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3705489\n"); + $fwrite(fp,"3284833\n"); end - xrf = 64'h400FFFF000002000; + x = 64'h800FFFFFFFFFFFFE; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3286847\n"); + end + x = 64'hC9F0FFFFFFDFFFFF; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h3F9FFFFFFFF00080; + ans = 64'hC9E0FFFFFFDFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3288861\n"); + end + x = 64'h402ECFB09EFE53B0; + y = 64'h7FDB75E2482305F2; + z = 64'hBE7899D950A5334F; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3290875\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3292889\n"); + end + x = 64'hC3DFFFFF00FFFFFE; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h406003FFFFFFFF7E; + ans = 64'hC3EFFFFF00FFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3294903\n"); + end + x = 64'h41F0000003FF7FFF; + y = 64'hD8801FBFFFFFFFFE; + z = 64'h4000028000000000; + ans = 64'hDA801FC004076EFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3296917\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3298931\n"); + end + x = 64'h401FFFFE07FFFFFE; + y = 64'h4010000000000001; + z = 64'hC1F7E00000000000; + ans = 64'hC1F7DFFFFE000020; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3300945\n"); + end + x = 64'hC015B720E5BE79F4; + y = 64'hFEFFF7FFFFBFFFFF; + z = 64'h0010001FFFFFFFDF; + ans = 64'h7F25B1B31D599C13; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3302959\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3304973\n"); + end + x = 64'h37FF00003FFFFFFE; + y = 64'h7FE0000000000001; + z = 64'h197A74ED682B8C08; + ans = 64'h77EF000040000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3306987\n"); + end + x = 64'h40100003FFFFFEFE; + y = 64'h402FFFFFF7F7FFFF; + z = 64'hCEAB55D2FAAD3C08; + ans = 64'hCEAB55D2FAAD3C08; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3309001\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3311015\n"); + end + x = 64'hC7FFFFFBFFFFFFF7; + y = 64'h8000000000000001; + z = 64'hC00FFEFFFFFF7FFF; + ans = 64'hC00FFEFFFFFF7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3313029\n"); + end + x = 64'hBFCBD9490F5D8F7B; + y = 64'h4803FFFFFDFFFFFF; + z = 64'hBF900007FFFF8000; + ans = 64'hC7E167CDA7DCE51B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3315043\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3317057\n"); + end + x = 64'hBF7FFF0000000007; + y = 64'hBCA0000000000000; + z = 64'h381FFFFFFFF7FFE0; + ans = 64'h3C2FFF0000000007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3319071\n"); + end + x = 64'h3F8000000000003F; + y = 64'hC1EFFEFFFFFFFFDF; + z = 64'h47E0000400003FFF; + ans = 64'h47E0000400003FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3321085\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hBFD0000000000001; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3323099\n"); + end + x = 64'hB7FFFEFFFFFFFF7E; + y = 64'hBFE0000000000000; + z = 64'h43FFF7FFFEFFFFFE; + ans = 64'h43FFF7FFFEFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3325113\n"); + end + x = 64'hBF9FF7FFFFFFFFFF; + y = 64'h41E828069D05F676; + z = 64'h401B3ADD2F8A8E68; + ans = 64'hC19821FC8023D7C8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3327127\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hBFF0000000000001; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3329141\n"); + end + x = 64'hC3E0400000000001; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h002FFC000000007F; + ans = 64'h43F0400000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3331155\n"); + end + x = 64'h3FFFFFFFF8010000; + y = 64'h3CA07FFFFC000000; + z = 64'hB80EFFFFFFEFFFFF; + ans = 64'h3CB07FFFF7E08401; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3333169\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hC010000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3335183\n"); + end + x = 64'h3FC000000000BFFF; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hBFEFFF9000000000; + ans = 64'hBFFFFFC80000BFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3337197\n"); + end + x = 64'hBFCDFFFFFC000000; + y = 64'hBF5000020001FFFF; + z = 64'h7FFFDFFFFFFFFF7F; + ans = 64'h7FFFDFFFFFFFFF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3339211\n"); + end + x = 64'h800FFFFFFFFFFFFE; + y = 64'hFFE0000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h3FFFFFFFFFFFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3341225\n"); + end + x = 64'hB6D007FDFFFFFFFE; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hBFA7283B2BE5BBEA; + ans = 64'h76D007FDFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3343239\n"); + end + x = 64'h3FD001FFFFFFFFF8; + y = 64'h002FFFFFFF80003F; + z = 64'hBFF1000000400000; + ans = 64'hBFF1000000400000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3345253\n"); + end + x = 64'h8010000000000000; + y = 64'h0000000000000000; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3347267\n"); + end + x = 64'h3FB000000800003F; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h3F421EDD58F82BF3; + ans = 64'h3F421EDD58F82BF3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3349281\n"); + end + x = 64'hCFC001007FFFFFFF; + y = 64'hC3DC23821C0039E3; + z = 64'h802FFFFDFFFFFFBF; + ans = 64'h53AC2545353E0AC5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3351295\n"); + end + x = 64'h8010000000000000; y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hBE300C0000000000; - ans = 64'hBE300C0000000000; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; rn = 1; rz = 0; rm = 0; @@ -283703,19 +78264,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -283731,105 +78292,8142 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3706103\n"); + $fwrite(fp,"3353309\n"); end - xrf = 64'hBCA0000000000001; - y = 64'h41EF00007FFFFFFE; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'hBE9F000080000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3706717\n"); - end - xrf = 64'h3E300000001FE000; - y = 64'hC030000008000000; - zrf = 64'h40CFFFDFFFFFFFF7; - ans = 64'h40CFFFDFFFFF7FF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3707331\n"); - end - xrf = 64'hBCA0000000000001; + x = 64'hC1C0000003FFFFFF; y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h3CAFFFFFFFFFFFFF; + z = 64'h3CA0000000002FFF; + ans = 64'hBE80000003BFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3355323\n"); + end + x = 64'h8024003FFFFFFFFF; + y = 64'h3F008000000007FF; + z = 64'h43F002FFFFFFFFFF; + ans = 64'h43F002FFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3357337\n"); + end + x = 64'h8010000000000000; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3359351\n"); + end + x = 64'hFFFDFEFFFFFFFFFE; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h3800010000000010; + ans = 64'hFFFDFEFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3361365\n"); + end + x = 64'h43CFFFFFFFFFFFE7; + y = 64'h406FFFFF87FFFFFF; + z = 64'hBFB53C1AA3282811; + ans = 64'h444FFFFF87FFFFE6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3363379\n"); + end + x = 64'h8010000000000000; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3365393\n"); + end + x = 64'h56B01FFFFFFFFF7F; + y = 64'h4000000000000001; + z = 64'h3FC007FFFFFFFFEF; + ans = 64'h56C01FFFFFFFFF80; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3367407\n"); + end + x = 64'hBFE000000BFFFFFF; + y = 64'h3FAFBFFFFC000000; + z = 64'hC7EFFEFF7FFFFFFE; + ans = 64'hC7EFFEFF7FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3369421\n"); + end + x = 64'h8010000000000000; + y = 64'h401FFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3371435\n"); + end + x = 64'h2CD0ACC2108D3F7E; + y = 64'h4340000000000001; + z = 64'hB8100001FFFFFFFA; + ans = 64'hB8100001FFFFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3373449\n"); + end + x = 64'hB891000000000006; + y = 64'h40000000003FF800; + z = 64'h380FFFFFFFFEFFDF; + ans = 64'hB8A0F8000043F7C6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3375463\n"); + end + x = 64'h8010000000000000; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h433FFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3377477\n"); + end + x = 64'hC80FFFFFFFFF003F; + y = 64'h7FF0000000000000; + z = 64'h7FE0000800000400; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3379491\n"); + end + x = 64'h40375A0C34C4B6A5; + y = 64'h3CAB57AB2349406C; + z = 64'hC0C0000000007FFF; + ans = 64'hC0C0000000007FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3381505\n"); + end + x = 64'h8010000000000000; + y = 64'h8000000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3383519\n"); + end + x = 64'h3FD00000000001FA; + y = 64'h8010000000000000; + z = 64'h3FB000000003FFF8; + ans = 64'h3FB000000003FFF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3385533\n"); + end + x = 64'hBFB03FFFFFFFFFFB; + y = 64'hFFD0617E96E1DFCD; + z = 64'hB810020000007FFE; + ans = 64'h7F90A304913D6747; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3387547\n"); + end + x = 64'h8010000000000000; + y = 64'hBCA0000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3389561\n"); + end + x = 64'hC1DC00FFFFFFFFFF; + y = 64'hBFD0000000000000; + z = 64'hBF8FFFE000001000; + ans = 64'h41BC00FFFFFC0003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3391575\n"); + end + x = 64'hFFD0008800000000; + y = 64'h802B2144A835A75B; + z = 64'h428000000000020F; + ans = 64'h4280000000001D31; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3393589\n"); + end + x = 64'h8010000000000000; + y = 64'hBFE0000000000001; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3395603\n"); + end + x = 64'h3F80001FFFFEFFFE; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h41DFC10000000000; + ans = 64'h41DFC0FFFFFF7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3397617\n"); + end + x = 64'hC0000000081FFFFF; + y = 64'hBFE0000400007FFF; + z = 64'h4F9ECE47311DB1DD; + ans = 64'h4F9ECE47311DB1DD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3399631\n"); + end + x = 64'h8010000000000000; + y = 64'hC000000000000000; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3401645\n"); + end + x = 64'hC01FFF0000FFFFFF; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h37AFFFFFFFFF7FFE; + ans = 64'h403FFF0000FFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3403659\n"); + end + x = 64'h43F13C60467832BD; + y = 64'hBF902003FFFFFFFE; + z = 64'h6170010000000008; + ans = 64'h6170010000000008; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3405673\n"); + end + x = 64'h8010000000000000; + y = 64'hC340000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3407687\n"); + end + x = 64'hCE17BB7913B68EBE; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'hFFDFFDFFFFFFBFFF; + ans = 64'hFFDFFDFFFFFFBFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3409701\n"); + end + x = 64'hC00FFFFC7FFFFFFF; + y = 64'h3FD7FFFFDFFFFFFF; + z = 64'hBCA000400000000E; + ans = 64'hBFF7FFFD4000037F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3411715\n"); + end + x = 64'h8010000000000000; + y = 64'hFFF0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3413729\n"); + end + x = 64'h3FBFFFFFFF6FFFFF; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h7FE0000007FFEFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3415743\n"); + end + x = 64'h3FBFFFFFEFBFFFFF; + y = 64'h3F600001FF7FFFFE; + z = 64'hBFC000FFFFFFFFFE; + ans = 64'hBFBFF1FFFE089FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3417757\n"); + end + x = 64'h8010000000000001; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3419771\n"); + end + x = 64'h41DFFFFFC0FFFFFF; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h3F94000007FFFFFF; + ans = 64'h3F94000007FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3421785\n"); + end + x = 64'h3FBFF7FFFFFFFFFD; + y = 64'h47F0203FFFFFFFFE; + z = 64'hC7FFFFFFFE00FFFE; + ans = 64'hC7FDFC790000FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3423799\n"); + end + x = 64'h8010000000000001; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3425813\n"); + end + x = 64'h41EFFFFFFFFF807F; + y = 64'h3FD0000000000001; + z = 64'hC01FEFFFFFFFF7FF; + ans = 64'h41CFFFFFFC018081; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3427827\n"); + end + x = 64'h40BFFFFFFFFC1FFE; + y = 64'hB7F27B1F5CF87205; + z = 64'h43FF080000000000; + ans = 64'h43FF080000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3429841\n"); + end + x = 64'h8010000000000001; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3431855\n"); + end + x = 64'hC077FFFFFFFFFF00; + y = 64'h3FF0000000000001; + z = 64'h0D79996219EE0031; + ans = 64'hC077FFFFFFFFFF01; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3433869\n"); + end + x = 64'h4248C62FE782EACE; + y = 64'hC1EFFE0000004000; + z = 64'h41DFFF7FFFFFFFFE; + ans = 64'hC448C4A38484642D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3435883\n"); + end + x = 64'h8010000000000001; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3437897\n"); + end + x = 64'h380CF72099FF042F; + y = 64'h4010000000000001; + z = 64'h43CFFFFEFC000000; + ans = 64'h43CFFFFEFC000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3439911\n"); + end + x = 64'h43D6FD1AAB74AF22; + y = 64'h3FC4000001000000; + z = 64'hC036977D15FCAD7C; + ans = 64'h43ACBC6157C1AC95; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3441925\n"); + end + x = 64'h8010000000000001; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3443939\n"); + end + x = 64'hC02003FFFFFF0000; + y = 64'h7FE0000000000000; + z = 64'hB800925EA3EAE96D; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3445953\n"); + end + x = 64'h800B5BF9E2135023; + y = 64'h41C428A0B2E99933; + z = 64'hC0CFFFFFE00003FF; + ans = 64'hC0CFFFFFE00003FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3447967\n"); + end + x = 64'h8010000000000001; + y = 64'h7FF0000000000001; + z = 64'hC340000000000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3449981\n"); + end + x = 64'h432A225C3E0BC75A; + y = 64'h8000000000000000; + z = 64'h2770000100000002; + ans = 64'h2770000100000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3451995\n"); + end + x = 64'h3F6675CC0F69D0EE; + y = 64'hBE0EFFFFDFFFFFFF; + z = 64'hB80FFFFFFF80FFFF; + ans = 64'hBD85C21D9878B656; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3454009\n"); + end + x = 64'h8010000000000001; + y = 64'h8010000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3456023\n"); + end + x = 64'hC7FA3FE7B36ABE4C; + y = 64'hBCA0000000000000; + z = 64'h9720001FFBFFFFFF; + ans = 64'h44AA3FE7B36ABE4C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3458037\n"); + end + x = 64'hC1FFFC0000000000; + y = 64'h693FFC0100000000; + z = 64'hF41FFFFFFFEEFFFF; + ans = 64'hF41FFFFFFFEEFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3460051\n"); + end + x = 64'h8010000000000001; + y = 64'hBFD0000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3462065\n"); + end + x = 64'hBDCFE00FFFFFFFFE; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hBFC000000200000F; + ans = 64'hBFC0000001F01007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3464079\n"); + end + x = 64'hE85BA35844A698B8; + y = 64'h43E000FFFFFBFFFF; + z = 64'h3C050A7780FB23F7; + ans = 64'hEC4BA5127A23FA4A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3466093\n"); + end + x = 64'h8010000000000001; + y = 64'hBFF0000000000000; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3468107\n"); + end + x = 64'h41100008000FFFFE; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h3FB1BAAC953356D1; + ans = 64'hC1200007DC9AA6D3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3470121\n"); + end + x = 64'h3DFFFF0000001FFF; + y = 64'h406FF08000000000; + z = 64'hC04000000807FFFF; + ans = 64'hC0400000070883FB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3472135\n"); + end + x = 64'h8010000000000001; + y = 64'hC010000000000000; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3474149\n"); + end + x = 64'h43D0BFFFFFFFFFFF; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h4020000000087FFE; + ans = 64'hC400BFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3476163\n"); + end + x = 64'h7FF000003FFFFFEF; + y = 64'hB7F8153138E3190F; + z = 64'h3FF000000081FFFE; + ans = 64'h7FF800003FFFFFEF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3478177\n"); + end + x = 64'h8010000000000001; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3480191\n"); + end + x = 64'h3FFF7FFFFFFBFFFF; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h0680000000FBFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3482205\n"); + end + x = 64'h0000000000000406; + y = 64'h3FFC81D6A5FF2C7A; + z = 64'hC1D0001FFFBFFFFE; + ans = 64'hC1D0001FFFBFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3484219\n"); + end + x = 64'h8010000000000001; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3486233\n"); + end + x = 64'hC3CB352D1CEBDE90; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hBF07D545D95AB53B; + ans = 64'hBF07D545D95AB53B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3488247\n"); + end + x = 64'h00000002FFFFFFFF; + y = 64'hC032140447A137B8; + z = 64'hC000FFFFFBFFFFFE; + ans = 64'hC000FFFFFBFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3490261\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3492275\n"); + end + x = 64'hBF5FFFBFFFFDFFFE; + y = 64'h3CA0000000000001; + z = 64'h3F1FFFFFFE0003FF; + ans = 64'h3F1FFFFFFE0003EF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3494289\n"); + end + x = 64'hC7EFFFFFFFFE7FFE; + y = 64'hC1D000FFFFFFF000; + z = 64'h3FE8282441DD2215; + ans = 64'h49D000FFFFFF2FF3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3496303\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3498317\n"); + end + x = 64'h403FFFFFFF801000; + y = 64'h3FE0000000000001; + z = 64'hBFF0803FFFFFFFFF; + ans = 64'h402DEFF7FF801002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3500331\n"); + end + x = 64'hAAA0FFFFBFFFFFFF; + y = 64'hD3CF400000000000; + z = 64'h43400FFFFFFFFFFE; + ans = 64'h43400FFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3502345\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3504359\n"); + end + x = 64'h5E78A4F96ABC9DE7; + y = 64'h4000000000000001; + z = 64'h47F8C8E01D92EAD7; + ans = 64'h5E88A4F96ABC9DE9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3506373\n"); + end + x = 64'hC0D0080000000007; + y = 64'h4011F8543DDEC32B; + z = 64'hC1E712DF030DCD92; + ans = 64'hC1E7130305AE9D8D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3508387\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3510401\n"); + end + x = 64'hC80FFDFFFDFFFFFF; + y = 64'h4340000000000000; + z = 64'h3FC0004200000000; + ans = 64'hCB5FFDFFFDFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3512415\n"); + end + x = 64'h801FFFFFFB800000; + y = 64'h41F3DFFFFFFFFFFF; + z = 64'hB590000002000FFF; + ans = 64'hB590000002000FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3514429\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h7FE0000000000001; + z = 64'hBFF0000000000001; + ans = 64'hC014000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3516443\n"); + end + x = 64'hC1FFFFFBC0000000; + y = 64'h7FF0000000000000; + z = 64'hC031FFFFFFFFBFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3518457\n"); + end + x = 64'h4800000000020003; + y = 64'h418800000000FFFF; + z = 64'h800468BF093C0C43; + ans = 64'h4998000000040004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3520471\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'h8000000000000001; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3522485\n"); + end + x = 64'h462284F38975D0BD; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h3FF0000080001000; + ans = 64'h3FF0000080001000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3524499\n"); + end + x = 64'h3F0B5811E180BC1D; + y = 64'hB800F845914088A3; + z = 64'hC1D507C7637918CE; + ans = 64'hC1D507C7637918CE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3526513\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hBCA0000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3528527\n"); + end + x = 64'h41F0000000002000; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hBFC1F235F0A8F509; + ans = 64'hBFC1F23DF0A8F509; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3530541\n"); + end + x = 64'hC3C0000010000003; + y = 64'hC343FF7FFFFFFFFF; + z = 64'h0B7FFFFFFFFFFFFF; + ans = 64'h4713FF8013FF8003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3532555\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hBFE0000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3534569\n"); + end + x = 64'hC07FFFFF7FFFFFBF; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hB81000007FFFFF7F; + ans = 64'h407FFFFF7FFFFFBD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3536583\n"); + end + x = 64'h43D5CDB51AEF5A02; + y = 64'hB80FFFFFFFBFFFBF; + z = 64'hC00001FFFFFFFFDE; + ans = 64'hC00001FFFFFFFFDE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3538597\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hC000000000000000; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3540611\n"); + end + x = 64'h4340008000007FFF; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h37EFFF7FDFFFFFFF; + ans = 64'hC360008000007FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3542625\n"); + end + x = 64'h403FFFFFFFE0007F; + y = 64'h816FFFFFFFFFFFFE; + z = 64'h41CFFFFFE003FFFF; + ans = 64'h41CFFFFFE003FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3544639\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3546653\n"); + end + x = 64'h434FFFFF7FF7FFFF; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h7FEFFFFFDFFFFFF7; + ans = 64'h7FEFFFFFDFFFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3548667\n"); + end + x = 64'hC02217A020FC8A2D; + y = 64'h3FA000020000001E; + z = 64'h3FCFFFBFFFFEFFFF; + ans = 64'hBFA0BE131F887378; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3550681\n"); + end + x = 64'h801FFFFFFFFFFFFF; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3552695\n"); + end + x = 64'h40A6E61F757B51A4; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hC04FFFFFFFFFC003; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3554709\n"); + end + x = 64'h406FDFFFFFFFFFF6; + y = 64'h000FFFFC00000002; + z = 64'h48CFDFE000000000; + ans = 64'h48CFDFE000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3556723\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3558737\n"); + end + x = 64'hFFF0008000000008; + y = 64'h0010000000000001; + z = 64'hBFB001000001FFFF; + ans = 64'hFFF8008000000008; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3560751\n"); + end + x = 64'hB49FFDFFDFFFFFFF; + y = 64'h7FFFFFFFFFFE03FF; + z = 64'hCE80000000000020; + ans = 64'h7FFFFFFFFFFE03FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3562765\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3564779\n"); + end + x = 64'hC01913F0B3195632; + y = 64'h3FD0000000000001; + z = 64'h987000000800003F; + ans = 64'hBFF913F0B3195634; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3566793\n"); + end + x = 64'hC00BC65690157317; + y = 64'hC030000000002001; + z = 64'h402D9EB7730C175F; + ans = 64'h40519702366C583F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3568807\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3570821\n"); + end + x = 64'h51013CBA56CFBF70; + y = 64'h3FF0000000000000; + z = 64'hE4603FFFFFFC0000; + ans = 64'hE4603FFFFFFC0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3572835\n"); + end + x = 64'h277491C48824332E; + y = 64'h401FFFBFFFFDFFFF; + z = 64'hFB3002001FFFFFFF; + ans = 64'hFB3002001FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3574849\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h4000000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3576863\n"); + end + x = 64'hB80F80000000001E; + y = 64'h4010000000000000; + z = 64'h802FC000000007FE; + ans = 64'hB82F80000000001E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3578877\n"); + end + x = 64'h3ABFFFFFFFFF0400; + y = 64'h400FFFFFFAFFFFFF; + z = 64'h37EFE0000000FFFF; + ans = 64'h3ADFFFFFFAFF043F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3580891\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h4340000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3582905\n"); + end + x = 64'h412F87FFFFFFFFFF; + y = 64'h7FE0000000000000; + z = 64'hBFC3FFFFFFFBFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3584919\n"); + end + x = 64'h6BFFFFFFFF7FFFFC; + y = 64'hEBE9A0EFE851BB03; + z = 64'hC3400001FFBFFFFE; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3586933\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h7FF0000000000001; + z = 64'h3FF0000000000001; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3588947\n"); + end + x = 64'hB17EFFDFFFFFFFFF; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hC3F9880289C16CA3; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3590961\n"); + end + x = 64'h41BA9212B83B0240; + y = 64'hFFD00011FFFFFFFF; + z = 64'hBE8AE163BEA821EC; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3592975\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'h8010000000000000; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3594989\n"); + end + x = 64'h43F0000000080001; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h380008003FFFFFFE; + ans = 64'h380008003FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3597003\n"); + end + x = 64'h41A33B5BA20B5DF5; + y = 64'hB96FFFFFF7FFFFFE; + z = 64'h800C8FD8F37D3D67; + ans = 64'hBB233B5B9D3C870B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3599017\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hBFD0000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3601031\n"); + end + x = 64'h47E00003FF7FFFFE; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hB81FFE0000010000; + ans = 64'hC7D00003FF7FFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3603045\n"); + end + x = 64'hB1F0001FFFFDFFFE; + y = 64'hC3F36C0AD01C4C5A; + z = 64'h3F4FFFFF7FFFBFFF; + ans = 64'h3F4FFFFF7FFFBFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3605059\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hBFF0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3607073\n"); + end + x = 64'hDD40000000FFFFFE; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h4020CF01046F2F61; + ans = 64'h5D50000000FFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3609087\n"); + end + x = 64'hBFF00000000000EF; + y = 64'h37E70C9A6B785725; + z = 64'h47FEFFFFFFFFFFF6; + ans = 64'h47FEFFFFFFFFFFF6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3611101\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3613115\n"); + end + x = 64'h21779D10D6196833; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hBFCFFFFFF01FFFFF; + ans = 64'hBFCFFFFFF01FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3615129\n"); + end + x = 64'h630FDFFFDFFFFFFF; + y = 64'hBFE00001FFFFFFFF; + z = 64'hBFFFFFDFEFFFFFFE; + ans = 64'hE2FFE003DBFFFBFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3617143\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3619157\n"); + end + x = 64'h37F0100000000200; + y = 64'hFFE0000000000001; + z = 64'h47E2000000003FFE; + ans = 64'hF7E0100000000201; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3621171\n"); + end + x = 64'h4030006000000000; + y = 64'hBFEFFFFFC7FFFFFE; + z = 64'hB229AA56F53BCE04; + ans = 64'hC030005FE3FF57FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3623185\n"); + end + x = 64'h801FFFFFFFFFFFFE; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3625199\n"); + end + x = 64'h3FF5950E99BFD4FF; + y = 64'h0000000000000001; + z = 64'hB82E3E751A766B11; + ans = 64'hB82E3E751A766B11; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3627213\n"); + end + x = 64'hCACFFFFFFFFEFFF6; + y = 64'h3FE000000000803F; + z = 64'h3F7153B79F878E9B; + ans = 64'hCAC000000000003A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3629227\n"); + end + x = 64'hBCA0000000000000; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3631241\n"); + end + x = 64'h3FE68CC51B1C1FB7; + y = 64'h3CA0000000000001; + z = 64'h19C05D99BA276601; + ans = 64'h3C968CC51B1C1FB8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3633255\n"); + end + x = 64'hBB60000000000000; + y = 64'h400FFBFFFFFFFFFC; + z = 64'h380FF80000020000; + ans = 64'hBB7FFBFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3635269\n"); + end + x = 64'hBCA0000000000000; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3637283\n"); + end + x = 64'h43F7AD836D8C6D79; + y = 64'h3FE0000000000000; + z = 64'h801FDFF800000000; + ans = 64'h43E7AD836D8C6D79; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3639297\n"); + end + x = 64'hBCAFFC000000FFFE; + y = 64'h41EFE02000000000; + z = 64'h7FD00000100001FF; + ans = 64'h7FD00000100001FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3641311\n"); + end + x = 64'hBCA0000000000000; + y = 64'h3FF0000000000001; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3643325\n"); + end + x = 64'hAA84000100000000; + y = 64'h4000000000000000; + z = 64'hC800000000010100; + ans = 64'hC800000000010100; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3645339\n"); + end + x = 64'h38402D46BA126A9F; + y = 64'h47E285F845923FD5; + z = 64'h5CC0010020000000; + ans = 64'h5CC0010020000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3647353\n"); + end + x = 64'hBCA0000000000000; + y = 64'h4010000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3649367\n"); + end + x = 64'hD90EFFFFFFFFEFFE; + y = 64'h4340000000000000; + z = 64'h80102000FFFFFFFF; + ans = 64'hDC5EFFFFFFFFEFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3651381\n"); + end + x = 64'hB7F04000003FFFFF; + y = 64'h7FD0FFFFFFE00000; + z = 64'h40CFD1C5180ACEAB; + ans = 64'hF7D1440000237FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3653395\n"); + end + x = 64'hBCA0000000000000; + y = 64'h7FE0000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hFC90000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3655409\n"); + end + x = 64'hC01A726A4A3AC5D3; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hBFE000000000020F; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3657423\n"); + end + x = 64'h4031000000008000; + y = 64'hC7F400000000FFFF; + z = 64'h43D184BDDA67AC33; + ans = 64'hC83540000001AFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3659437\n"); + end + x = 64'hBCA0000000000000; + y = 64'h8000000000000000; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3661451\n"); + end + x = 64'h0BF000008000007F; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h3207A5FB27F86F0F; + ans = 64'h3207A5FB27F86F0F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3663465\n"); + end + x = 64'hCF80007FBFFFFFFF; + y = 64'hFFDFDFFFFF7FFFFF; + z = 64'hF0BED0A6285C8414; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3665479\n"); + end + x = 64'hBCA0000000000000; + y = 64'hBCA0000000000000; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3667493\n"); + end + x = 64'hCB000000000000F8; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h4F30040000100000; + ans = 64'h4F30040000100000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3669507\n"); + end + x = 64'hC020000027FFFFFE; + y = 64'h6EFFFFFFFFFF8003; + z = 64'h4013D748E0532C46; + ans = 64'hEF30000027FFBFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3671521\n"); + end + x = 64'hBCA0000000000000; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3673535\n"); + end + x = 64'hC7F0FAF5DCDF1C46; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hBFD000000003FFFB; + ans = 64'h47F0FAF5DCDF1C45; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3675549\n"); + end + x = 64'h76C453FC3A9FC346; + y = 64'h47D00FC000000000; + z = 64'h7FDECA60D8A5DECB; + ans = 64'h7FDECA6365A5BBA8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3677563\n"); + end + x = 64'hBCA0000000000000; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hB960000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3679577\n"); + end + x = 64'hCC80000FFE000000; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hD9BA017626C9D9C9; + ans = 64'hD9BA017626C9D9C9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3681591\n"); + end + x = 64'h3FD0108000000000; + y = 64'h5EA627EA240A0174; + z = 64'hCA1000000008007E; + ans = 64'h5E863EC34D7F2BC5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3683605\n"); + end + x = 64'hBCA0000000000000; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000005; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3685619\n"); + end + x = 64'hBED470C16CA5A9A9; + y = 64'hC340000000000001; + z = 64'h3FD0020000000008; + ans = 64'h422470C16CA629BA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3687633\n"); + end + x = 64'hE987FFE000000000; + y = 64'h3FEFFFFFFC00003E; + z = 64'hA0EB2EA4CE828FBC; + ans = 64'hE987FFDFFD00042E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3689647\n"); + end + x = 64'hBCA0000000000000; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'h7C9FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3691661\n"); + end + x = 64'h3FE00000040000FF; + y = 64'hFFF0000000000001; + z = 64'h403E6153BAC38ACC; + 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,"3693675\n"); + end + x = 64'h0000000000003FFF; + y = 64'hC346F75321C70778; + z = 64'hBFFFFFFFFFFF9FFF; + ans = 64'hBFFFFFFFFFFF9FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3695689\n"); + end + x = 64'hBCA0000000000001; + y = 64'h000FFFFFFFFFFFFF; + 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,"3697703\n"); + end + x = 64'h42409BDB0E8B5BAC; + y = 64'h0010000000000001; + z = 64'h425DE476106384F2; + ans = 64'h425DE476106384F2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3699717\n"); + end + x = 64'hABBE8F16F3FE1C83; + y = 64'hC17000007FF80000; + z = 64'h404AE1CA4CBB15D7; + ans = 64'h404AE1CA4CBB15D7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3701731\n"); + end + x = 64'hBCA0000000000001; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; ans = 64'h3CAFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -283844,19 +86442,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -283872,12 +86470,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3707945\n"); + $fwrite(fp,"3703745\n"); end - xrf = 64'h5AE01000000000FF; - y = 64'hB7E000000000000B; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hD2D010000000010A; + x = 64'h37E01000000000FF; + y = 64'h3FD0000000000000; + z = 64'h4019662DF874E479; + ans = 64'h4019662DF874E479; rn = 1; rz = 0; rm = 0; @@ -283891,19 +86489,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -283919,12 +86517,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3708559\n"); + $fwrite(fp,"3705759\n"); end - xrf = 64'hBCA0000000000001; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'hBF600010003FFFFF; - ans = 64'hBF600010003FFFFF; + x = 64'hBE6DFFFFFFFFFF7E; + y = 64'hC0A555407160BC9B; + z = 64'h3FFEB19129135086; + ans = 64'h3FFEB2312876A2DC; rn = 1; rz = 0; rm = 0; @@ -283938,19 +86536,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -283966,12 +86564,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3709173\n"); + $fwrite(fp,"3707773\n"); end - xrf = 64'h3FC0100000001000; - y = 64'h3FBFFDFFFFFFFFFB; - zrf = 64'h3F68007FFFFFFFFF; - ans = 64'h3F930F0F00000FFC; + x = 64'hBCA0000000000001; + y = 64'h3FE0000000000001; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; rn = 1; rz = 0; rm = 0; @@ -283985,19 +86583,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -284015,433 +86613,10 @@ initial if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); $fwrite(fp,"3709787\n"); end - xrf = 64'hBFA0000000100003; - y = 64'h3FD0000000000001; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h3FEFBFFFFFFFBFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3710401\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h483000000FFFDFFF; - zrf = 64'hC1F2000000000008; - ans = 64'hC4E000000FFFE024; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3711015\n"); - end - xrf = 64'hFFFE0A678C624F99; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h44A36355884BDF32; - ans = 64'hFFFE0A678C624F99; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3711629\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h7FF03FC000000000; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h7FF83FC000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3712243\n"); - end - xrf = 64'h4194827E2F7BD16C; - y = 64'hC90FFFFFFFFFE800; - zrf = 64'hC3DF000000000008; - ans = 64'hCAB4827E2F7BC20A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3712857\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h3FE0000000000001; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'hBC90000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3713471\n"); - end - xrf = 64'hC040003FEFFFFFFF; - y = 64'h3FDFFFFFFFFF8000; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3714085\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'hBFF0400000000400; - ans = 64'hBFF0400000000401; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3714699\n"); - end - xrf = 64'h38000000000005FF; - y = 64'hFFEFFFF7FFFFFFF7; - zrf = 64'hC6C0000120000000; - ans = 64'hF7FFFFF800000BF5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3715313\n"); - end - xrf = 64'h802000000001FFF7; + x = 64'hB800400000FFFFFF; y = 64'h3FF0000000000000; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE0000000000000; + z = 64'hBF8001000000007F; + ans = 64'hBF8001000000007F; rn = 1; rz = 0; rm = 0; @@ -284455,19 +86630,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -284483,12 +86658,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3715927\n"); + $fwrite(fp,"3711801\n"); end - xrf = 64'hBCA0000000000001; - y = 64'hC02E0D532183CA7C; - zrf = 64'h3FCD7D34563A15FD; - ans = 64'h3FCD7D34563A1639; + x = 64'h3F7FFFFFFFFFF7FC; + y = 64'hC1E1FFFFFFFFFFDE; + z = 64'hC03FFFFF80000400; + ans = 64'hC1720001FFFFF35C; rn = 1; rz = 0; rm = 0; @@ -284502,19 +86677,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -284530,8612 +86705,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3716541\n"); + $fwrite(fp,"3713815\n"); end - xrf = 64'hEB5FFFFFDFBFFFFF; - y = 64'h3FF0000000000001; - zrf = 64'h409CBF6F4C076C92; - ans = 64'hEB5FFFFFDFC00001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3717155\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h000FFFFFC000001E; - zrf = 64'h8000000000000000; - ans = 64'h8000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3717769\n"); - end - xrf = 64'hBFBFDFFFFFFBFFFF; - y = 64'h41DFFFFFF0010000; - zrf = 64'hE69FFFBFFEFFFFFF; - ans = 64'hE69FFFBFFEFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3718383\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h4000000000000000; - zrf = 64'h0010000000000000; - ans = 64'hBCB0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3718997\n"); - end - xrf = 64'hC0D000000007FDFF; - y = 64'h41D00000FFFFF7FE; - zrf = 64'hC010000000000001; - ans = 64'hC2B000010007F9FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3719611\n"); - end - xrf = 64'hBCA0000000000001; + x = 64'hBCA0000000000001; y = 64'h4000000000000001; - zrf = 64'hB84FBFFFFFFFFFFF; - ans = 64'hBCB0000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3720225\n"); - end - xrf = 64'h3F8000000001FFFA; - y = 64'hFFEFFC000000001F; - zrf = 64'h50A000000001E000; - ans = 64'hFF7FFC000003FF93; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3720839\n"); - end - xrf = 64'h40E0240000000000; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h3FD0000000000001; - ans = 64'h41002401FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3721453\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h802000003F7FFFFE; - zrf = 64'h38DFFFFFFFBFC000; - ans = 64'h38DFFFFFFFBFC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3722067\n"); - end - xrf = 64'h4378DAD7F8CB6D2E; - y = 64'h4010000000000000; - zrf = 64'hBFB007FFFFFEFFFF; - ans = 64'h4398DAD7F8CB6D2E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3722681\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h43EFFFE7FFFFFFFF; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3723295\n"); - end - xrf = 64'hB7FFFFFFFFFFF8FF; - y = 64'hC3E4000000010000; - zrf = 64'h36EB61110674A849; - ans = 64'h3BF400000000FB9F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3723909\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h0000000000000001; - ans = 64'hBCD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3724523\n"); - end - xrf = 64'h400FFFFFE0000080; - y = 64'h4F6FFFFFF0000000; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'h4F8FFFFFD0000090; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3725137\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h4340000000000000; - zrf = 64'hB9F00040007FFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3725751\n"); - end - xrf = 64'h480DFFEFFFFFFFFF; - y = 64'hBFCFFFEFFFFFF800; - zrf = 64'h3EA00000003FDFFF; - ans = 64'hC7EDFFE10007F87F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3726365\n"); - end - xrf = 64'hB800000001FFFDFF; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFEFFFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3726979\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h1B9FFFFFE000FFFF; - zrf = 64'h3FEFEFFFBFFFFFFE; - ans = 64'h3FEFEFFFBFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3727593\n"); - end - xrf = 64'hBF7FFFFFFBFEFFFE; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h403636BB565E6ADF; - ans = 64'hC2DFFFFFFBFEFA6E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3728207\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h3FB00001FFFC0000; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3728821\n"); - end - xrf = 64'hFFEF9571FF100553; - y = 64'hBE7FFFFE03FFFFFF; - zrf = 64'hBFBFFFFBFF000000; - ans = 64'h7E7F957009AB93A1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3729435\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h7FE0000000000001; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3730049\n"); - end - xrf = 64'hB81FFFFF8003FFFE; - y = 64'h400020001FFFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hBFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3730663\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h9F80000003FFFFEE; - ans = 64'hFCA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3731277\n"); - end - xrf = 64'hC15800000000003E; - y = 64'h4EE09FFFFFFFFFFF; - zrf = 64'hBFCFFFFFFFFFFF7F; - ans = 64'hD048F0000000003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3731891\n"); - end - xrf = 64'hC770007FFFFFFFEF; - y = 64'h7FF0000000000001; - zrf = 64'h001FFFFFFFFFFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3732505\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h7FDA7310ABEAE84F; - zrf = 64'h48A73ACD31EA4F8E; - ans = 64'hFC8A7310ABEAE851; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3733119\n"); - end - xrf = 64'hC0D60CA21F4AD012; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'hBFD4DCE5D90DAA50; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3733733\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h401FF7FFFFFFFDFF; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3734347\n"); - end - xrf = 64'h477FFFF7FFFFBFFF; - y = 64'h41D00200000FFFFF; - zrf = 64'hBFBFFFFFFFFFFFD8; - ans = 64'h496001FBFF8FDFF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3734961\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h8000000000000000; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3735575\n"); - end - xrf = 64'h3F10000003BFFFFE; - y = 64'h3E1FFFFFFFFFFFFF; - zrf = 64'hBFF0000000000000; - ans = 64'hBFEFFFFFFFFFFC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3736189\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hC03B09EA7C43FEA2; - ans = 64'hC03B09EA7C43FEA2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3736803\n"); - end - xrf = 64'hC1EFFFBFFFFFFFFD; - y = 64'h7FFFFEFFFFFFFFFA; - zrf = 64'h000FFFC07FFFFFFF; - ans = 64'h7FFFFEFFFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3737417\n"); - end - xrf = 64'h779C6B30A6ACCE58; - y = 64'h8010000000000000; - zrf = 64'h0010000000000000; - ans = 64'hB7BC6B30A6ACCE58; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3738031\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h3FBD242FF9F7C369; - zrf = 64'h403E470AB2DD2D1D; - ans = 64'h403E470AB2DD2D1D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3738645\n"); - end - xrf = 64'h380EFFFFFFFFFFFD; - y = 64'h8010000000000001; - zrf = 64'hBFA501B829A23C23; - ans = 64'hBFA501B829A23C23; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3739259\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h47FFFC00003FFFFF; - zrf = 64'h4340000000000000; - ans = 64'hC4AFFBFFC0400001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3739873\n"); - end - xrf = 64'h8015D7ABA4BF48ED; - y = 64'h3F1FFFFFF7FFFFFE; - zrf = 64'h7FEE2DBEE5C2D97E; - ans = 64'h7FEE2DBEE5C2D97E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3740487\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3741101\n"); - end - xrf = 64'h3FE00001FFFC0000; - y = 64'h3FCB2596D8FD2EB9; - zrf = 64'hBFE0000000000001; - ans = 64'hBFD936997095AFE5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3741715\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'hBCA0000000000001; - zrf = 64'h4073FFFFEFFFFFFE; - ans = 64'h4073FFFFEFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3742329\n"); - end - xrf = 64'hD2F0B2C9A70221FF; - y = 64'h43E199DDC5665EB1; - zrf = 64'hFFE84B6CAA717C29; - ans = 64'hFFE84B6CAA717C29; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3742943\n"); - end - xrf = 64'hD94FF81000000000; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h0000000000000001; - ans = 64'h560FF80FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3743557\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h400FFFFFF7FFFDFF; - zrf = 64'hB4DFEFFFFFFFFF7F; - ans = 64'hBCBFFFFFF7FFFE01; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3744171\n"); - end - xrf = 64'hC52FFEFFFFFFBFFE; - y = 64'hBFD0000000000000; - zrf = 64'hBFA0000FFFFFFE00; - ans = 64'h450FFEFFFFFFBFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3744785\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'hBFFB106850049EF2; - zrf = 64'h4010000000000001; - ans = 64'h4010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3745399\n"); - end - xrf = 64'h43429BCA2DC4DCB8; - y = 64'h29FDFFFFFFFFF800; - zrf = 64'h4340200080000000; - ans = 64'h4340200080000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3746013\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3746627\n"); - end - xrf = 64'hC250FFFFFFFFFFFE; - y = 64'hC14A4CD328768347; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'h43ABF1A05AFDEB78; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3747241\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'hBFE0000000000000; - zrf = 64'h480FC01FFFFFFFFF; - ans = 64'h480FC01FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3747855\n"); - end - xrf = 64'h3FD200000001FFFF; - y = 64'h3F80000400800000; - zrf = 64'hB810FFFFFFFFFFFC; - ans = 64'h3F62000480920000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3748469\n"); - end - xrf = 64'hB810100000000000; - y = 64'hBFE0000000000001; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3749083\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h41DFFFFFFFFF0003; - zrf = 64'h3CA0001FFFFFFFFB; - ans = 64'hBE8FFFFFFFBEFF85; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3749697\n"); - end - xrf = 64'hFFF20001FFFFFFFF; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hBFBBFFFFFFFFFBFF; - ans = 64'hFFFA0001FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3750311\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'hBCAFF00003FFFFFF; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h400FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3750925\n"); - end - xrf = 64'h43DFFFFFFF7FFFC0; - y = 64'h231F2EC23DED0C48; - zrf = 64'h518EFFFFC0000000; - ans = 64'h518EFFFFC0000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3751539\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'hBFF0000000000001; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3752153\n"); - end - xrf = 64'hC08FFFFEE0000000; - y = 64'h43FE83C87C2780E4; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hC49E83C769857487; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3752767\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hBFE90AAFA45FC660; - ans = 64'hBFE90AAFA45FC65E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3753381\n"); - end - xrf = 64'hC1F97E13BBA0D54D; - y = 64'h434FFF80000000FF; - zrf = 64'h41E200003FFFFFFF; - ans = 64'hC5597DADC351E795; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3753995\n"); - end - xrf = 64'h3FC3FF7FFFFFFFFF; - y = 64'hC000000000000000; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3754609\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h41E00000000000FD; - zrf = 64'h748FFFFFFDF7FFFF; - ans = 64'h748FFFFFFDF7FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3755223\n"); - end - xrf = 64'h37FBBEB4E97ED446; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h7FE9E49884FB358B; - ans = 64'h7FE9E49884FB358B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3755837\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'hC7FFFFFFF0001FFF; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h44AFFFFFF0002001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3756451\n"); - end - xrf = 64'hC3E000000207FFFF; - y = 64'h3FE0000000004003; - zrf = 64'hC1D200000000000F; - ans = 64'hC3D00000021A4002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3757065\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'hC010000000000000; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3757679\n"); - end - xrf = 64'hC1E000000000DFFF; - y = 64'h47EFFFE7FFFFFFFF; - zrf = 64'hBCA0000000000000; - ans = 64'hC9DFFFE80001BFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3758293\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hC180000000001003; - ans = 64'hC180000000001003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3758907\n"); - end - xrf = 64'h3F20407FFFFFFFFF; - y = 64'hFFD01FFFFFFFFFFE; - zrf = 64'hC1DFFFFFFE00001F; - ans = 64'hFF006100FFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3759521\n"); - end - xrf = 64'h3AD0000000001FDF; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3760135\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'hC1D0000FFFFFFFFD; - zrf = 64'h001022851DC3F35C; - ans = 64'h3E80000FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3760749\n"); - end - xrf = 64'hB7EFFFFFFDFFFFE0; - y = 64'hC340000000000001; - zrf = 64'h43F103FFFFFFFFFE; - ans = 64'h43F103FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3761363\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'hC80C020548AB0BD7; - zrf = 64'h3FF0000000000000; - ans = 64'h44BC020548AB0BD9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3761977\n"); - end - xrf = 64'h8A7EFFFFFFFFFFF7; - y = 64'h42620001FFFFFFFF; - zrf = 64'hC1D000001000FFFE; - ans = 64'hC1D000001000FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3762591\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hC000000000000000; - ans = 64'hB980000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3763205\n"); - end - xrf = 64'h7FFFFE00003FFFFE; - y = 64'h3FB0000000107FFE; - zrf = 64'h8010000000000001; - ans = 64'h7FFFFE00003FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3763819\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'hFFE0000000000001; - zrf = 64'h47EF19603D95F25F; - ans = 64'h7C90000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3764433\n"); - end - xrf = 64'h434FC6B058E8DB04; - y = 64'hC7F0001F7FFFFFFE; - zrf = 64'h09BFFFFFFFFEFEFF; - ans = 64'hCB4FC6EEE8140A0A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3765047\n"); - end - xrf = 64'hBD2000107FFFFFFF; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hC340000000000001; - ans = 64'h7D2000107FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3765661\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h7FDFFFFFFFFFEFDF; - zrf = 64'hC00FFF01FFFFFFFE; - ans = 64'hFC8FFFFFFFFFEFE1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3766275\n"); - end - xrf = 64'hC1EFF8000000000F; - y = 64'hFFF0000000000000; - zrf = 64'h403E18E7F4D1673B; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3766889\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'h5D80000001003FFF; - zrf = 64'h3FE0000000000001; - ans = 64'hDA30000001004000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3767503\n"); - end - xrf = 64'h7FE433DE65AD5CF1; - y = 64'hBFB00000004001FF; - zrf = 64'h7FF0000008000001; - ans = 64'h7FF8000008000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3768117\n"); - end - xrf = 64'hBCA0000000000001; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hBFF0000000000001; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3768731\n"); - end - xrf = 64'hFE4FF0FFFFFFFFFE; - y = 64'hBCA0000040003FFE; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h7AFFF1007FC47FBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3769345\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h0000000000000000; - zrf = 64'hC3CFEFFF7FFFFFFF; - ans = 64'hC3CFEFFF7FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3769959\n"); - end - xrf = 64'hC02000003FFFFFFE; - y = 64'h05300005FFFFFFFF; - zrf = 64'hC0810000007FFFFE; - ans = 64'hC0810000007FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3770573\n"); - end - xrf = 64'hC01FFE00000001FF; - y = 64'h0000000000000001; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3771187\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hDADFFFFFFFFFFFF8; - zrf = 64'hC3CFDFFFFFFBFFFF; - ans = 64'h579FFFFFFFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3771801\n"); - end - xrf = 64'h0020000000002080; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h3F0FFFFFFC080000; - ans = 64'h3F0FFFFFFC080000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3772415\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hC7F0000000001FFC; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h44B0000000001FFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3773029\n"); - end - xrf = 64'hC3F4695058A6C40E; - y = 64'h4040080000000000; - zrf = 64'hB83FFFFDFFFFFFBE; - ans = 64'hC444738500D31770; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3773643\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h0010000000000001; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3774257\n"); - end - xrf = 64'hC1F00000077FFFFE; - y = 64'hAB2000800000007F; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3774871\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hFFF3EC28CD007481; - ans = 64'hFFFBEC28CD007481; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3775485\n"); - end - xrf = 64'h3FFC94ABE6867525; - y = 64'hC67E87B31ABFDBF0; - zrf = 64'h4012000FFFFFFFFF; - ans = 64'hC68B449454D84E0E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3776099\n"); - end - xrf = 64'hFFD6F486F2DE1EE8; - y = 64'h3CA0000000000000; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hFC86F486F2DE1EE8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3776713\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hBFCD146D2EEB9817; - zrf = 64'h43E00040007FFFFF; - ans = 64'h43E00040007FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3777327\n"); - end - xrf = 64'hC80FF7FFFF7FFFFF; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h43FFFFFFFFE001FE; - ans = 64'hC4CFF6FFFF8000FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3777941\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hC032000000000004; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h3CF3000000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3778555\n"); - end - xrf = 64'h4060001FBFFFFFFF; - y = 64'hC00F8CABD8D44234; - zrf = 64'h342DFF7FFFFFFFFF; - ans = 64'hC07F8CEA73F94477; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3779169\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h3FD0000000000000; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3779783\n"); - end - xrf = 64'h402BFFFFFFFFFFFF; - y = 64'hC34F36F54B2B6FAA; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3780397\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hBFBFFFFFF800000E; - ans = 64'hBFBFFFFFF8000016; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3781011\n"); - end - xrf = 64'h3FFFEFFFFFFFFFEF; - y = 64'hB7F0000FFC000000; - zrf = 64'hB73003FFFFFFF000; - ans = 64'hB7FFF1202803FFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3781625\n"); - end - xrf = 64'h0023A4E6A0757395; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'hC000000000000000; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3782239\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h3FF8E39EA08CCCC9; - zrf = 64'h3810000000BFFFFF; - ans = 64'hBCB8E39EA08CCCC8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3782853\n"); - end - xrf = 64'h47DFFFFFFFFFFDBF; - y = 64'h3FE0000000000001; - zrf = 64'hC3EFFFE000001000; - ans = 64'h47CFFFFFFFFFFDC1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3783467\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hCD9C9445CD63D125; - zrf = 64'h3CA0000000000000; - ans = 64'h4A5C9445CD63D124; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3784081\n"); - end - xrf = 64'hC02F7FFFEFFFFFFF; - y = 64'hC03FFBFFFFFFFFEF; - zrf = 64'hBCAFFFFFFFC3FFFE; - ans = 64'h407F7C0FF001FFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3784695\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'hBFD0000000000000; - ans = 64'hBFD0000000000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3785309\n"); - end - xrf = 64'hBFFFFFFFFFFF0000; - y = 64'hBFFD7E746AFB16D4; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3785923\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h3FF0000000000001; - zrf = 64'h3FB81E1E1999C633; - ans = 64'h3FB81E1E1999C623; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3786537\n"); - end - xrf = 64'hC7E573ADD2BD9CFF; - y = 64'hBFD0001FFFFFFFDE; - zrf = 64'h3FD47F130055411E; - ans = 64'h47C573D8BA19424D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3787151\n"); - end - xrf = 64'h8721FFFFFFEFFFFF; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3787765\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h3FC200001FFFFFFF; - zrf = 64'h3FDFFFF00000FFFF; - ans = 64'h3FDFFFF00000FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3788379\n"); - end - xrf = 64'h401FFFF80000001E; - y = 64'h4000000000000000; - zrf = 64'hB7E4881AB2642528; - ans = 64'h402FFFF80000001E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3788993\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h3FE328C04730D7AB; - zrf = 64'h0010000000000001; - ans = 64'hBCA328C04730D7AA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3789607\n"); - end - xrf = 64'h3FC44EB15655CF8C; - y = 64'hBFB001000000000F; - zrf = 64'hC611C5D9D036DBD6; - ans = 64'hC611C5D9D036DBD6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3790221\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hBCA0000000000001; - ans = 64'hBCD1FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3790835\n"); - end - xrf = 64'h7FD0000000020FFF; - y = 64'hC087364277477C0D; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3791449\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h4010000000000000; - zrf = 64'h405FFFFC0000000E; - ans = 64'h405FFFFC0000000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3792063\n"); - end - xrf = 64'hB80FFFF80000001F; - y = 64'h7FD824F9FC677296; - zrf = 64'hC1ECDC90E18A4273; - ans = 64'hF7F824F3F328F394; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3792677\n"); - end - xrf = 64'hBFBFFFFFFFFFFFFF; - y = 64'h4010000000000001; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFF8000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3793291\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h381FFBFFFFFFFF7E; - zrf = 64'h402FFBFFFFEFFFFF; - ans = 64'h402FFBFFFFEFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3793905\n"); - end - xrf = 64'h3E8000002FFFFFFF; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h401FFFF6FFFFFFFE; - ans = 64'h401FFFF7400000BE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3794519\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h37E7518E920E9CB8; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hB4A7518E920E9CB7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3795133\n"); - end - xrf = 64'hFFFC634E56F80E2B; - y = 64'hC00FFE00007FFFFE; - zrf = 64'hC5927F0A4882C3A0; - ans = 64'hFFFC634E56F80E2B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3795747\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h4340000000000001; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3796361\n"); - end - xrf = 64'h40F8845913A28A1B; - y = 64'h3CAFFF00000007FE; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h4020000000003106; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3796975\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h3FAC643DA383C0B4; - ans = 64'hC00F8E6F0971F0FA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3797589\n"); - end - xrf = 64'h403FFFFFFFFFFB7F; - y = 64'h37F8000003FFFFFF; - zrf = 64'h41D020000000007E; - ans = 64'h41D020000000007E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3798203\n"); - end - xrf = 64'hBE92EA44B97B547E; - y = 64'h7FE0000000000000; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hFE82EA44B97B547E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3798817\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hBE5FFFFFFFFFBFF0; - zrf = 64'hBFB000000FFFFFBF; - ans = 64'hBFB000000FFFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3799431\n"); - end - xrf = 64'hC1E0000001FDFFFF; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h400BDB005C4DF29B; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3800045\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hC3D25C01DBF7A016; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3800659\n"); - end - xrf = 64'hB7EBFEDEC7BFCAE2; - y = 64'h002C4A674B537A5C; - zrf = 64'hBB70000018000000; - ans = 64'hBB70000018000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3801273\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h7FF0000000000000; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3801887\n"); - end - xrf = 64'h403FDFDFFFFFFFFE; - y = 64'h543C00000000007F; - zrf = 64'h4010000000000000; - ans = 64'h548BE3E40000007D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3802501\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h45B518F9DBC8077E; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3803115\n"); - end - xrf = 64'h388FFFFFFE001FFE; - y = 64'hB80B0B869627BF01; - zrf = 64'h40869F3B701EF024; - ans = 64'h40869F3B701EF024; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3803729\n"); - end - xrf = 64'h403FFFFFFFFE1FFE; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'hBFD0000000000000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3804343\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h002B6C86ECDC9502; - zrf = 64'h221BE5101396B494; - ans = 64'h221BE5101396B494; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3804957\n"); - end - xrf = 64'h3F9007FFFFBFFFFE; - y = 64'h8000000000000001; - zrf = 64'hC04FFFFFFFFFFBFB; - ans = 64'hC04FFFFFFFFFFBFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3805571\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h480FFFFFFFF7F000; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3806185\n"); - end - xrf = 64'hC3D84640FD57069E; - y = 64'hC6FD409D3113A6A2; - zrf = 64'hBB5A99581212CBD0; - ans = 64'h4AE630AEA57AE2A1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3806799\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h8000000000000000; - ans = 64'h0000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3807413\n"); - end - xrf = 64'h3FC4CD0E86115DD9; - y = 64'hC06FFFFFFBFFFFFE; - zrf = 64'h4000000000000001; - ans = 64'hC043CD0E8377BC07; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3808027\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h8010000000000001; - zrf = 64'hC0CFFEFFFFFFE000; - ans = 64'hC0CFFEFFFFFFE000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3808641\n"); - end - xrf = 64'h480EFFFFFFFFFFF7; - y = 64'hC027FFFFFFFDFFFF; - zrf = 64'hC1C3FFE000000000; - ans = 64'hC8473FFFFFFE0FF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3809255\n"); - end - xrf = 64'h800000000001FFDF; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3809869\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h37FFFFFFFFE0000F; - zrf = 64'h43F8DD02D524E71E; - ans = 64'h43F8DD02D524E71E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3810483\n"); - end - xrf = 64'h40307FFFFFF7FFFF; - y = 64'hBCA0000000000000; - zrf = 64'h3FCFFFFFFFFFBFEF; - ans = 64'h3FCFFFFFFFFFBFAD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3811097\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h3FDFFFFFFFFFFBDF; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3811711\n"); - end - xrf = 64'hB82000040000000F; - y = 64'h37FFFFFFE00007FE; - zrf = 64'h33300001FFFFFEFE; - ans = 64'h33300001FFFFFEEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3812325\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3812939\n"); - end - xrf = 64'hFFF01FFFFFFFFFDF; - y = 64'h3CA00000005FFFFF; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'hFFF81FFFFFFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3813553\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hBFD0000000000000; - zrf = 64'hFFDE00000000003F; - ans = 64'hFFDE00000000003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3814167\n"); - end - xrf = 64'hBE26336215FE569D; - y = 64'hC02000000FFFFFFB; - zrf = 64'hBFC0800000000FFF; - ans = 64'hBFC07FFFD3994BA7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3814781\n"); - end - xrf = 64'hC1F00000C0000000; - y = 64'hBFD0000000000001; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h41D00000C0000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3815395\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hC1D0000020000001; - zrf = 64'hBF9FFFFFFFF7FFFC; - ans = 64'hBF9FFFEFFFF7DFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3816009\n"); - end - xrf = 64'hC1C00000003FEFFF; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'hBFF3FFFFFFFF8000; - ans = 64'h41AFFFFFFDFFDFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3816623\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h43DFC00000000010; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC3500000000001FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3817237\n"); - end - xrf = 64'h04F0001FFFFFFFFE; - y = 64'h3FBFFFFFFFFFFF1E; - zrf = 64'h41C003EFFFFFFFFF; - ans = 64'h41C003EFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3817851\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hBFE0000000000001; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3818465\n"); - end - xrf = 64'h48351C562148E3C3; - y = 64'hC3C0001040000000; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'hCC051C6B92105D91; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3819079\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h357FFFFFFFC00002; - ans = 64'h3CAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3819693\n"); - end - xrf = 64'hCD920007FFFFFFFE; - y = 64'hBFF0008000000006; - zrf = 64'hBFD0008000003FFF; - ans = 64'h4D92009800400005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3820307\n"); - end - xrf = 64'hE8E000007FFFFEFF; - y = 64'hBFF0000000000000; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h68E000007FFFFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3820921\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h475FFFFFFBF7FFFE; - zrf = 64'hC3D273DDF2EFC5D4; - ans = 64'hC420939EED937E2D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3821535\n"); - end - xrf = 64'hC1DBFFFFFFFFE000; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h3F71FFFFFEFFFFFF; - ans = 64'h41EC0000000003FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3822149\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h3FFB7AD5DBD8ECB4; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3822763\n"); - end - xrf = 64'hC1DFFFFFFFF00400; - y = 64'h3600000001FDFFFE; - zrf = 64'h387002000003FFFF; - ans = 64'h386FE400000413FA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3823377\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hC000000000000000; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3823991\n"); - end - xrf = 64'hC33000000000207F; - y = 64'hC06003FFFFFFFFE0; - zrf = 64'h3FE0000000000000; - ans = 64'h43A0040000002067; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3824605\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hC000000000000001; - zrf = 64'hBFB00000FFF7FFFE; - ans = 64'hBFB00000FFF7FFDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3825219\n"); - end - xrf = 64'hC03CAA2122BCDDA8; - y = 64'h07EFFFF01FFFFFFE; - zrf = 64'h790FFFFFFFF007FF; - ans = 64'h790FFFFFFFF007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3825833\n"); - end - xrf = 64'h800DFFFFFF000000; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h8000000000000000; - ans = 64'h002BFFFFFDFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3826447\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h3FB00041FFFFFFFF; - zrf = 64'hED24C95B210BCE74; - ans = 64'hED24C95B210BCE74; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3827061\n"); - end - xrf = 64'hBCDFFFFBFFFFFFEF; - y = 64'hC010000000000001; - zrf = 64'h3FE2B79A1255D879; - ans = 64'h3FE2B79A1255D8B9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3827675\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hBFB611A62F90914B; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3828289\n"); - end - xrf = 64'h086FFDFFFFF7FFFE; - y = 64'h3F3FFFC00000001F; - zrf = 64'h3D1FF7FFFF7FFFFF; - ans = 64'h3D1FF7FFFF7FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3828903\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h4340000000000000; + z = 64'h4340000000000000; ans = 64'h4340000000000000; rn = 1; rz = 0; @@ -293150,19 +86724,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -293178,7767 +86752,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3829517\n"); + $fwrite(fp,"3715829\n"); end - xrf = 64'h09B0000000FFFFEF; - y = 64'hE16F29F8FCB12F99; - zrf = 64'h3FD0000000000001; - ans = 64'h3FD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3830131\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hC340000000000000; - zrf = 64'hC04000000FEFFFFF; - ans = 64'hC03E00001FDFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3830745\n"); - end - xrf = 64'hC8001FF7FFFFFFFF; - y = 64'h97DA61766F44B5D2; - zrf = 64'hC02FFFFFFE010000; - ans = 64'hC02FFFFFFE010000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3831359\n"); - end - xrf = 64'h40300000000E0000; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3831973\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h4340000000000200; - zrf = 64'h7FD8E66F7F1B72EF; - ans = 64'h7FD8E66F7F1B72EF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3832587\n"); - end - xrf = 64'hC3D9284299249F71; - y = 64'hFFE0000000000000; - zrf = 64'h001269432C741CE2; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3833201\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hC34000000801FFFE; - zrf = 64'hC000000000000001; - ans = 64'h3E7003FFF8FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3833815\n"); - end - xrf = 64'h3FC0000100000FFF; - y = 64'h402F2113B98F4D3F; - zrf = 64'h41F5067733275A4B; - ans = 64'h41F5067733467B61; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3834429\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h4010000000000001; - ans = 64'h7CAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3835043\n"); - end - xrf = 64'h41FEFFFFF7FFFFFE; - y = 64'h3FDE27B3C3560C4A; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h41ED36761DB16EF5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3835657\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'hBFC01FFF00000000; - ans = 64'h7CAFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3836271\n"); - end - xrf = 64'hA140000020FFFFFF; - y = 64'hC02200000001FFFF; - zrf = 64'hA270000007FFFFDF; - ans = 64'hA26FFFDC0FFFB57A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3836885\n"); - end - xrf = 64'h3FCFFFFFFF80000F; - y = 64'hFFF0000000000001; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3837499\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'hC1E0010000000040; - zrf = 64'h001FFEFFFFFFFFBF; - ans = 64'h3EA001000000003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3838113\n"); - end - xrf = 64'hBE2FDFBFFFFFFFFE; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hC3E0000000000402; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3838727\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFF; - y = 64'h401FFFFF7FFFFDFE; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hC000000000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3839341\n"); - end - xrf = 64'h400AF78C8712BABC; - y = 64'h8020003FFFFFDFFE; - zrf = 64'h3F0FFFFF02000000; - ans = 64'h3F0FFFFF02000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3839955\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h0000000000000001; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h400FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3840569\n"); - end - xrf = 64'h47FCF758F173AEC0; - y = 64'hB81000003FBFFFFE; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'hC01CF75964DD351E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3841183\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'hBFE4000000007FFF; - ans = 64'hBFE4000000007FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3841797\n"); - end - xrf = 64'h407017FFFFFFFFFF; - y = 64'hC34C07FFFFFFFFFF; - zrf = 64'h3A6F7FFBFFFFFFFF; - ans = 64'hC3CC320BFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3842411\n"); - end - xrf = 64'h47F000000027FFFF; - y = 64'h0010000000000000; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3843025\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'hB7F003FFFFFFEFFE; - zrf = 64'hC5B7A0673EADC9A4; - ans = 64'hC5B7A0673EADC9A4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3843639\n"); - end - xrf = 64'h409020000003FFFF; - y = 64'h0010000000000001; - zrf = 64'hC00FF00000000400; - ans = 64'hC00FF00000000400; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3844253\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'hC01623760D068163; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hBFEFFFFFFFFFFFF3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3844867\n"); - end - xrf = 64'h093FFE0000000001; - y = 64'hBE42C37D10FC5DBF; - zrf = 64'hBF9EDB6E0C31FE0D; - ans = 64'hBF9EDB6E0C31FE0D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3845481\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h3CA0000000000000; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h3FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3846095\n"); - end - xrf = 64'hBFF0800000020000; - y = 64'h002FFFFFFFFFFDE0; - zrf = 64'h0010000000000000; - ans = 64'h802900000003FDCF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3846709\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h3CA0000000000001; - zrf = 64'h41EFF8000000003E; - ans = 64'h41EFF8000000003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3847323\n"); - end - xrf = 64'hC008000001FFFFFF; - y = 64'h4037FFFFDFFFFFFF; - zrf = 64'h3C5020000007FFFE; - ans = 64'hC051FFFFE97FFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3847937\n"); - end - xrf = 64'h43D286A2997C9FAA; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h4340000000000000; - ans = 64'h4340000000000251; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3848551\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h402D452A3DF3776D; - zrf = 64'hC1EFFFFFFFEFFFBF; - ans = 64'hC1EFFFFFFFEFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3849165\n"); - end - xrf = 64'h4007FFFFFFFFFF7F; - y = 64'h3FD0000000000000; - zrf = 64'h7FD5398280BE5715; - ans = 64'h7FD5398280BE5715; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3849779\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h41FF6F065BD57EC9; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE00003EDE0CB7B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3850393\n"); - end - xrf = 64'h56CFFFFC00007FFF; - y = 64'hC3FFFDFFFFC00000; - zrf = 64'hB890000040001FFF; - ans = 64'hDADFFDFC00007FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3851007\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h3FF0000000000000; - ans = 64'h3FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3851621\n"); - end - xrf = 64'h4031E6B8C563AF80; - y = 64'hBCAFFFFFFF8000FF; - zrf = 64'h0000000000000001; - ans = 64'hBCF1E6B8C51C152C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3852235\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h3FE0000000000000; - zrf = 64'hBF463F4F8D229935; - ans = 64'hBF463F4F8D229D35; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3852849\n"); - end - xrf = 64'hACAFFFFFFFFFFFFB; - y = 64'hC0100000207FFFFF; - zrf = 64'h3FEFFFFFF01FFFFE; - ans = 64'h3FEFFFFFF01FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3853463\n"); - end - xrf = 64'h001FFFC000000000; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h4010000000000001; - ans = 64'h4010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3854077\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h2929BC17AB77C1CB; - zrf = 64'h3F203FFFFFFFFFFD; - ans = 64'h3F203FFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3854691\n"); - end - xrf = 64'hBFFE5222CB6C08EC; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'hC02FEFFFFFFFFFDF; - ans = 64'hC031DD222CB6C07E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3855305\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'hB807EFFFFFFFFFFF; - zrf = 64'hBFD0000000000001; - ans = 64'hBFD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3855919\n"); - end - xrf = 64'hF05000000080007E; - y = 64'hC1F00007FFFFFF7F; - zrf = 64'h4014EE1CFC92B761; - ans = 64'h725000080080003D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3856533\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h3FE0000000000001; - ans = 64'h3FDFFFFFFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3857147\n"); - end - xrf = 64'hC02DFBFFFFFFFFFE; - y = 64'h47AFF00000080000; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3857761\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h3FCF4975D48A2613; - ans = 64'h3FCF4975D48A2603; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3858375\n"); - end - xrf = 64'hC0FAFEC2EE7775CF; - y = 64'h447FFFFFFFFFFFFF; - zrf = 64'h3FBF000000FFFFFF; - ans = 64'hC58AFEC2EE7775CE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3858989\n"); - end - xrf = 64'h45EEE82BC0898FB7; - y = 64'h4000000000000001; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h45FEE82BC0898FB9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3859603\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h402FFFFFFFF00200; - zrf = 64'hACDFFFDFFFFFFDFE; - ans = 64'hBCEFFFFFFFF001FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3860217\n"); - end - xrf = 64'h41300001FFFFEFFF; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h41C3B0198D9CC68F; - ans = 64'h41C3D019919CC66F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3860831\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h41A0000200002000; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBE60000202001FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3861445\n"); - end - xrf = 64'h401D7976478C5506; - y = 64'h41EFFFFFFF800200; - zrf = 64'h37FFF07FFFFFFFFF; - ans = 64'h421D797647167104; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3862059\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h4010000000000001; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FDFFFFFFFFFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3862673\n"); - end - xrf = 64'h37E200FFFFFFFFFF; - y = 64'hBFF00000008001FF; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3863287\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h3FBF000007FFFFFF; - ans = 64'h3FBF000007FFFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3863901\n"); - end - xrf = 64'h706FFFFFFFEFEFFF; - y = 64'hBB2007994AC8C940; - zrf = 64'h43EFFFFFF0000001; - ans = 64'hEBA007994AC0BD6F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3864515\n"); - end - xrf = 64'hBFDFFEFFFDFFFFFE; - y = 64'h4340000000000000; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'hC32FFEFFFDFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3865129\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h7D2A71E23A26FE39; - zrf = 64'hC3CEDFFFFFFFFFFF; - ans = 64'hF9EA71E23A26FE37; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3865743\n"); - end - xrf = 64'hB7E7FFEFFFFFFFFF; - y = 64'h4340000000000001; - zrf = 64'h3FF0262BF9110EA2; - ans = 64'h3FF0262BF9110EA2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3866357\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'hFFF28BE96C71A6EB; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'hFFFA8BE96C71A6EB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3866971\n"); - end - xrf = 64'hC34BFFBFFFFFFFFE; - y = 64'h4020003FFFFFFFFC; - zrf = 64'hC000000000000203; - ans = 64'hC37C002FFEFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3867585\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h7FE0000000000000; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'hFC9FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3868199\n"); - end - xrf = 64'h4070000000000047; - y = 64'h3FD001FFFFFFFFF6; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3868813\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h7FE0000000000001; - zrf = 64'h41C000F800000000; - ans = 64'hFCA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3869427\n"); - end - xrf = 64'h480000000800007F; - y = 64'hC1DFFFFFFFFFFFFE; - zrf = 64'h480D431676A71F4C; - ans = 64'hC9F0000007C57A51; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3870041\n"); - end - xrf = 64'hC1E0C51250FC8976; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h3FF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3870655\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h41EE000000000007; - zrf = 64'hC1E010000007FFFE; - ans = 64'hC1E0100000080000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3871269\n"); - end - xrf = 64'h41AFF68C1CC9C0A1; - y = 64'h7FF0000000000000; - zrf = 64'h434FFFFFFFBFFEFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3871883\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h3FFFFFFFBFFFBFFF; - zrf = 64'h8010000000000000; - ans = 64'hBCBFFFFFBFFFBFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3872497\n"); - end - xrf = 64'h400DC9E58AFDDB5A; - y = 64'h47EFFFFDFFFFFFFA; - zrf = 64'h001FFFFFFFFFC200; - ans = 64'h480DC9E3AE5F82A5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3873111\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h3CA0000000000000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3873725\n"); - end - xrf = 64'hBFF0007FFFBFFFFF; - y = 64'hBFDCC57F4F7CBEBC; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3874339\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h8000000000000000; - zrf = 64'h5E2FFFFFFFFFFFE8; - ans = 64'h5E2FFFFFFFFFFFE8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3874953\n"); - end - xrf = 64'hBE91FFFFFFFFFFFA; - y = 64'h40A000000FFFBFFF; - zrf = 64'hC0207FEFFFFFFFFE; - ans = 64'hC0208038000047FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3875567\n"); - end - xrf = 64'h3FFFC001FFFFFFFE; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h3FE0000000000001; - ans = 64'h3FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3876181\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'hC1A000000000006E; - zrf = 64'h37E0000100010000; - ans = 64'h3E6000000000006D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3876795\n"); - end - xrf = 64'h3FEFF7EFFFFFFFFF; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'hFFD3413A55613D63; - ans = 64'hFFD3413A55613D63; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3877409\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h001FFFFFFFFC0000; - zrf = 64'h8000000000000001; - ans = 64'h8000000000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3878023\n"); - end - xrf = 64'hCE58341C1FDF7D8E; - y = 64'hC02FFFFFFFFE0007; - zrf = 64'hC340010000100000; - ans = 64'h4E98341C1FDDFA52; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3878637\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h0010000000000001; - ans = 64'h0010000000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3879251\n"); - end - xrf = 64'hCDFFFFFFFFFF803F; - y = 64'h52CFBFFFE0000000; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hE0DFBFFFDFFF813F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3879865\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'hBC7000007FFFFFBF; - ans = 64'hBC7000007FFFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3880479\n"); - end - xrf = 64'h7FFFFFDFFFFFF7FF; - y = 64'hBFFEAF36380E1453; - zrf = 64'h43401FFFFFFEFFFF; - ans = 64'h7FFFFFDFFFFFF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3881093\n"); - end - xrf = 64'hC7E000000000041F; - y = 64'hBCA0000000000001; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h4490000000000420; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3881707\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h4340011FFFFFFFFF; - zrf = 64'hC48F000001FFFFFF; - ans = 64'hC48F000001FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3882321\n"); - end - xrf = 64'hFFFBFFFFFFFFFEFF; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h3F400000011FFFFE; - ans = 64'hFFFBFFFFFFFFFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3882935\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h40207F0000000000; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3883549\n"); - end - xrf = 64'h971F800000001FFE; - y = 64'hD6EC0000FFFFFFFF; - zrf = 64'h38DFFFFFFC000001; - ans = 64'h38DFFFFFFC000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3884163\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'hBFD0000000000001; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h3C90000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3884777\n"); - end - xrf = 64'h7943721AAF4997DF; - y = 64'h4F40100000001FFE; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3885391\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hC03DFFFFEFFFFFFE; - ans = 64'hC03DFFFFEFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3886005\n"); - end - xrf = 64'hC02FFFFFFFFD0000; - y = 64'h409FFFFFE0003FFF; - zrf = 64'h41F000800000000E; - ans = 64'h41F000780000080F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3886619\n"); - end - xrf = 64'hBCA8CBF09B3D0FC8; - y = 64'hBFE0000000000000; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h3CB632FC26CF43F1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3887233\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'hBFE0000004000040; - zrf = 64'h3FCA4E5DFC5F64A6; - ans = 64'h3FCA4E5DFC5F64AA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3887847\n"); - end - xrf = 64'hC7FFF000000FFFFF; - y = 64'hBFE0000000000001; - zrf = 64'h3B988E26CAA0A643; - ans = 64'h47EFF00000100001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3888461\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'hBFFA89B78C407B0B; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3889075\n"); - end - xrf = 64'h7FEC5FED92358A74; - y = 64'h400000001BFFFFFF; - zrf = 64'hFFEFC0003FFFFFFE; - ans = 64'h7FE8FFDB47BAD466; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3889689\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3890303\n"); - end - xrf = 64'h3E5003FFFFFFFFFE; - y = 64'h42A0000100000008; - zrf = 64'hC000000000000000; - ans = 64'h410003F100400006; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3890917\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'hBFF0000000000001; - zrf = 64'h3F90FFFE00000000; - ans = 64'h3F90FFFE00000040; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3891531\n"); - end - xrf = 64'h43A379C662D1E18D; - y = 64'hBFEFFFFFFFFFFE0E; - zrf = 64'hCE7FFD7FFFFFFFFF; - ans = 64'hCE7FFD7FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3892145\n"); - end - xrf = 64'h3F700000000BFFFE; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h3CA0000000000000; - ans = 64'hBF800000000BFFBD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3892759\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'hB81AEAA04CF56914; - zrf = 64'h43EFE00000010000; - ans = 64'h43EFE00000010000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3893373\n"); - end - xrf = 64'hBFFEFFFFFEFFFFFE; - y = 64'hC000000000000000; - zrf = 64'h9CF00401FFFFFFFE; - ans = 64'h400EFFFFFEFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3893987\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'hBF1FC0000001FFFF; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3894601\n"); - end - xrf = 64'h48000200000007FF; - y = 64'hC7E804BB70801D06; - zrf = 64'h402BCF7F1D62AAF3; - ans = 64'hCFF807BC07EE390A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3895215\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3895829\n"); - end - xrf = 64'hC01816EFAAB2D8D7; - y = 64'hC3DFFFBFFFFF7FFF; - zrf = 64'hBFF0000000000001; - ans = 64'h440816BF7CD32315; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3896443\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'hC010000000000000; - zrf = 64'h37F8101B8771DC21; - ans = 64'h3CCFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3897057\n"); - end - xrf = 64'hC347ED246FACE56C; - y = 64'h41B00000FFFFFBFF; - zrf = 64'hC3C01FFFFFFFE000; - ans = 64'hC507ED26F07F266A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3897671\n"); - end - xrf = 64'h43D34792C6A02B3D; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h0010000000000001; - ans = 64'hC4034792C6A02B3C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3898285\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h801974EC8F423A9C; - zrf = 64'h7FEFFFFFFFFFF5FE; - ans = 64'h7FEFFFFFFFFFF5FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3898899\n"); - end - xrf = 64'hBFD000001FFFFF7F; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hC6C6597A88729CE8; - ans = 64'hC6C6597A88729CE8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3899513\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'hC1DFFFFFFFFDDFFF; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3900127\n"); - end - xrf = 64'h3E90001FFFFBFFFF; - y = 64'h000007FFFFFFFEFF; - zrf = 64'h43FFEFFFFFFFFFEF; - ans = 64'h43FFEFFFFFFFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3900741\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'hC340000000000001; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3901355\n"); - end - xrf = 64'h354C0618970ED58A; - y = 64'hC29FFFFDFFFFFFFB; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3901969\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hBFEFC000FFFFFFFF; - ans = 64'h40080FFFBFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3902583\n"); - end - xrf = 64'hC008000007FFFFFF; - y = 64'hC3E0007FDFFFFFFE; - zrf = 64'hC020001FFFF7FFFE; - ans = 64'h43F800BFD8003FEC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3903197\n"); - end - xrf = 64'h7FE037FFFFFFFFFF; - y = 64'hFFE0000000000001; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3903811\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h43EFFFFFFFFFC1FF; - zrf = 64'hC08FFFFFFFFFE080; - ans = 64'hC0B3FFFFFFFFDD0F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3904425\n"); - end - xrf = 64'hC1C000000001007E; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h37F0000000000808; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3905039\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'h47EE1258EDCF0B99; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'hC4AE1258EDCF0B97; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3905653\n"); - end - xrf = 64'hC01FF00100000000; - y = 64'h37E2C1CE2980BFCB; - zrf = 64'hBFF000C000000000; - ans = 64'hBFF000C000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3906267\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'hFFF0000000000000; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3906881\n"); - end - xrf = 64'h415FED03662395C2; - y = 64'h3CF003FFFFC00000; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFE00B0158; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3907495\n"); - end - xrf = 64'hBCAFFFFFFFFFFFFE; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hB81FFFFFFFFFF7C0; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3908109\n"); - end - xrf = 64'h7FEFFFDFFFFFF000; - y = 64'h3E92B79EE102830F; - zrf = 64'h404FF80002000000; - ans = 64'h7E92B78C296398B1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3908723\n"); - end - xrf = 64'h3FCFFFFFFFFFEEFE; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3909337\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hC463FFFFFFFF7FFF; - zrf = 64'hB80FFFFFFF0001FE; - ans = 64'h4443FFFFFFFF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3909951\n"); - end - xrf = 64'h41DFFF7FFFFFFFFD; - y = 64'h0000000000000001; - zrf = 64'h40074A735CCC3D1A; - ans = 64'h40074A735CCC3D1A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3910565\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hBE700000003DFFFE; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h4010000000FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3911179\n"); - end - xrf = 64'hC0EFFFFFFFFFFBFE; - y = 64'hBFB5337C5E8A0ADB; - zrf = 64'h403FFFFFFFF80100; - ans = 64'h40B5537C5E8A0034; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3911793\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3912407\n"); - end - xrf = 64'h40FBFFEFFFFFFFFF; - y = 64'h407BCCA8CD7A0FA4; - zrf = 64'hBFD0000000000000; - ans = 64'h41885305CB7666F2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3913021\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h0010000000000001; - zrf = 64'h47FBFF8000000000; - ans = 64'h47FBFF8000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3913635\n"); - end - xrf = 64'h80070F86D26AF87F; - y = 64'h402D24956BD2F299; - zrf = 64'h3FEFFFFFFEFFFFDF; - ans = 64'h3FEFFFFFFEFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3914249\n"); - end - xrf = 64'h802FB75B257B0ED8; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3914863\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h3E10000000000000; - zrf = 64'hB7E8C5327331971D; - ans = 64'hBDF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3915477\n"); - end - xrf = 64'h3FF0020000010000; - y = 64'h3CA0000000000000; - zrf = 64'hBFDBFFFFFFFFFFC0; - ans = 64'hBFDBFFFFFFFFFFBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3916091\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h3ABFFFFFF7FFBFFF; - zrf = 64'h4000000000000000; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3916705\n"); - end - xrf = 64'h3FCB02720DAF3235; - y = 64'h43E4A66C2CF152B0; - zrf = 64'h41DFC544AD43CD91; - ans = 64'h43C16DFF46A401F7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3917319\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3917933\n"); - end - xrf = 64'hB7E00000003BFFFF; - y = 64'h3FDFFFFFFFF7DFFF; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3918547\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h3FD0000000000000; - zrf = 64'h48000000000FFE00; - ans = 64'h48000000000FFE00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3919161\n"); - end - xrf = 64'hC03B47150C9A9B6D; - y = 64'hB2100800000001FF; - zrf = 64'h41200001FFFFFBFE; - ans = 64'h41200001FFFFFBFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3919775\n"); - end - xrf = 64'hC800003FFFEFFFFF; - y = 64'h3FD0000000000001; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3920389\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h43CFFFFFFFFEDFFE; - zrf = 64'h7FD69279CD05B983; - ans = 64'h7FD69279CD05B983; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3921003\n"); - end - xrf = 64'hBFDE7D87C0913C02; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h3FDFFF7FFFFFBFFE; - ans = 64'h3FD0C0BC1FB721FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3921617\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hBFCFFF8000008000; - zrf = 64'h3FF0000000000001; - ans = 64'h3FF0FFFC00000401; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3922231\n"); - end - xrf = 64'hE561400000000000; - y = 64'h3370010000000080; - zrf = 64'h3FEFFC0000000FFF; - ans = 64'hD8E141140000008A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3922845\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h3FE0000000000001; - zrf = 64'hC000000000000001; - ans = 64'hC001000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3923459\n"); - end - xrf = 64'hB61FDFFFFFFFFF80; - y = 64'hC07FF7FFF7FFFFFF; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h36AFD807F807FF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3924073\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h6F9000201FFFFFFF; - ans = 64'h6F9000201FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3924687\n"); - end - xrf = 64'hF8A00000400007FF; - y = 64'hC3CFFFFFFFFFE000; - zrf = 64'hBCD00FFFFFFFFFF6; - ans = 64'h7C8000003FFFF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3925301\n"); - end - xrf = 64'hC020000007FFFFBF; - y = 64'h3FF0000000000000; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC350000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3925915\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hC9F4F59F1F927A15; - zrf = 64'h45E2000000000007; - ans = 64'h49D4F59F1F927A15; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3926529\n"); - end - xrf = 64'h7FFE000000000003; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h8027230E8C392E66; - ans = 64'h7FFE000000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3927143\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h402881AE9E66C7A0; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'hC00081AE9E66C7A0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3927757\n"); - end - xrf = 64'h3FF07FF000000000; - y = 64'hB7E591AE07EF0EC1; - zrf = 64'hBFA20001FFFFFFFE; - ans = 64'hBFA20001FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3928371\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h4000000000000000; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hC004000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3928985\n"); - end - xrf = 64'h41F0000000FFF7FE; - y = 64'hB43FFFFFE0000000; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hB63FFFFFE1FFEFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3929599\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h401FFFF7FFFFBFFF; - ans = 64'h401BFFF7FFFFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3930213\n"); - end - xrf = 64'h41E0020007FFFFFE; - y = 64'hBFCFFFFFFFF80000; - zrf = 64'h41CC685C7196EB8B; - ans = 64'h41B8CCB8D335D81A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3930827\n"); - end - xrf = 64'hD59FFFFFFFFFFF02; + x = 64'hC34FFFFFE0000000; y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hD5BFFFFFFFFFFF00; + z = 64'h3F70003FFFFFFFFF; + ans = 64'hC36FFFFFDFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -300952,19 +86771,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -300980,12 +86799,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3931441\n"); + $fwrite(fp,"3717843\n"); end - xrf = 64'hBFD0000000000000; - y = 64'h3ECF0000001FFFFE; - zrf = 64'hC07FFFFFF7FFFF00; - ans = 64'hC07FFFFFF8F7FF00; + x = 64'h3CAFFFE00FFFFFFE; + y = 64'h17600000BFFFFFFF; + z = 64'hBCB0000078000000; + ans = 64'hBCB0000078000000; rn = 1; rz = 0; rm = 0; @@ -300999,19 +86818,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -301027,12 +86846,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3932055\n"); + $fwrite(fp,"3719857\n"); end - xrf = 64'hD3207FFFF8000000; - y = 64'h4010000000000001; - zrf = 64'h802FFF7FF7FFFFFF; - ans = 64'hD3407FFFF8000001; + x = 64'hBCA0000000000001; + y = 64'h4340000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -301046,19 +86865,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -301074,12 +86893,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3932669\n"); + $fwrite(fp,"3721871\n"); end - xrf = 64'hBFD0000000000000; - y = 64'hC1E000000000EFFF; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h41C000000040EFFF; + x = 64'hBEC0008000003FFE; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h3FB14DEC1EB3BA6A; + ans = 64'hC220008000001D61; rn = 1; rz = 0; rm = 0; @@ -301093,19 +86912,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -301121,12 +86940,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3933283\n"); + $fwrite(fp,"3723885\n"); end - xrf = 64'h47E0001FFEFFFFFF; - y = 64'h3E00080001FFFFFF; - zrf = 64'h3F80400001FFFFFE; - ans = 64'h45F0082010FF83FE; + x = 64'h384FFF8FFFFFFFFE; + y = 64'hBFEE93E820EBFBFC; + z = 64'h3FE6840810AD9CD5; + ans = 64'h3FE6840810AD9CD5; rn = 1; rz = 0; rm = 0; @@ -301140,19 +86959,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -301168,528 +86987,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3933897\n"); + $fwrite(fp,"3725899\n"); end - xrf = 64'hBFD0000000000000; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hC007FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3934511\n"); - end - xrf = 64'h43CFFFFFFFFFBFFC; - y = 64'h48000103FFFFFFFF; - zrf = 64'h8000000000000000; - ans = 64'h4BE00103FFFFDFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3935125\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h4340000000000001; - zrf = 64'hB2A1894A6694767C; - ans = 64'hC320000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3935739\n"); - end - xrf = 64'hBFF00000001FFFDF; - y = 64'h43E49E7F564BB504; - zrf = 64'h3FDFF80000800000; - ans = 64'hC3E49E7F5674F1D8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3936353\n"); - end - xrf = 64'h326FFF0000001FFF; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3936967\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hBFB0000080800000; - zrf = 64'h5CBFFFFFFFC00010; - ans = 64'h5CBFFFFFFFC00010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3937581\n"); - end - xrf = 64'hC04C000000000002; - y = 64'h7FE0000000000000; - zrf = 64'hC7F0003FFF800000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3938195\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hB7F00000000FEFFE; - zrf = 64'h3FD0000000000000; - ans = 64'h3FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3938809\n"); - end - xrf = 64'hC07FFFFF000000FF; - y = 64'h401FFFFFFC000800; - zrf = 64'hBFFE3FFFFFFFFFFF; - ans = 64'hC0B001E37E00048F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3939423\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hBFE0000000000000; - ans = 64'hFFCFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3940037\n"); - end - xrf = 64'h43D45470894BB8A8; - y = 64'hC03FBFFFBFFFFFFF; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3940651\n"); - end - xrf = 64'hBFD0000000000000; + x = 64'hBCA0000000000001; y = 64'h7FF0000000000000; - zrf = 64'hC0100000000077FF; + z = 64'hBCAFFFFFFFFFFFFF; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -301704,19 +87006,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -301732,152 +87034,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3941265\n"); + $fwrite(fp,"3727913\n"); end - xrf = 64'hC1CF9BD668BBFDD4; - y = 64'h47FFFFFFFC00000F; - zrf = 64'h3FF0000203FFFFFE; - ans = 64'hC9DF9BD664C88316; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3941879\n"); - end - xrf = 64'h94B6F716776052E0; - y = 64'h7FF0000000000001; - zrf = 64'hC000000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3942493\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h7FF0001000001FFE; - zrf = 64'h3FCD83E74EDEE6A0; - ans = 64'h7FF8001000001FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3943107\n"); - end - xrf = 64'h3F8FFFFFDFFFBFFF; + x = 64'hC3EF0000000000FE; y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h3ECFE0003FFFFFFE; + z = 64'h3F59E5826298B6A1; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -301892,19 +87053,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -301920,12 +87081,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3943721\n"); + $fwrite(fp,"3729927\n"); end - xrf = 64'hBFD0000000000000; - y = 64'h43C6363479265EB6; - zrf = 64'h3CA0000000000001; - ans = 64'hC3A6363479265EB6; + x = 64'h47F000000200FFFE; + y = 64'hC03FFFEFFFDFFFFF; + z = 64'h40E004000000000E; + ans = 64'hC83FFFF003E1FDFA; rn = 1; rz = 0; rm = 0; @@ -301939,19 +87100,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -301967,1750 +87128,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3944335\n"); + $fwrite(fp,"3731941\n"); end - xrf = 64'hBE7FFFFFE0007FFF; - y = 64'h3F8FFFFFFFFFF820; - zrf = 64'h48000000003FFE00; - ans = 64'h48000000003FFE00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3944949\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h8000000000000001; - zrf = 64'hBFD0000000000001; - ans = 64'hBFD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3945563\n"); - end - xrf = 64'h7FFE5CD16B7C0732; - y = 64'h3CADFFFFFFDFFFFF; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FFE5CD16B7C0732; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3946177\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h409BFFFFEFFFFFFF; - ans = 64'h409BFFFFEFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3946791\n"); - end - xrf = 64'hBF9FFFFFEFFFFFC0; - y = 64'h381EF14093430C09; - zrf = 64'hD060000FFFFFC000; - ans = 64'hD060000FFFFFC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3947405\n"); - end - xrf = 64'h00200001FFFFF000; + x = 64'hBCA0000000000001; y = 64'h8010000000000000; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3948019\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h8023FFFFFFFFFFF6; - zrf = 64'hC3EFFFFFFFFF007F; - ans = 64'hC3EFFFFFFFFF007F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3948633\n"); - end - xrf = 64'hA60FDFFFBFFFFFFF; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'hC7FBFFC000000000; - ans = 64'hC7FBFFC000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3949247\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h498168AE9F10A60B; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'hC96168AE9F10A60B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3949861\n"); - end - xrf = 64'h400FFFEFFBFFFFFF; - y = 64'h3FC000FF7FFFFFFF; - zrf = 64'h4F83DECC52B7FEC8; - ans = 64'h4F83DECC52B7FEC8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3950475\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hBCA0000000000000; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCABFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3951089\n"); - end - xrf = 64'h000FFF7FFBFFFFFE; - y = 64'h37EFFE003FFFFFFE; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3951703\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h7FF00000000007FF; - ans = 64'h7FF80000000007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3952317\n"); - end - xrf = 64'h3FB00000000BFFFF; - y = 64'hC1F4D10E1B0B1A8D; - zrf = 64'h323FFFFFC000003E; - ans = 64'hC1B4D10E1B1AB756; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3952931\n"); - end - xrf = 64'hFE40041FFFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'h7B00041FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3953545\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hC1CFFFFF00000080; - zrf = 64'h592B8A3E51BB758C; - ans = 64'h592B8A3E51BB758C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3954159\n"); - end - xrf = 64'hB7E28718D241C8CE; - y = 64'hBFD0000000000001; - zrf = 64'hC5BFFFE00000000F; - ans = 64'hC5BFFFE00000000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3954773\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hC1C0ECDAF428D873; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h41A0ECDAF428D873; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3955387\n"); - end - xrf = 64'hC1D01FFFFEFFFFFF; - y = 64'hBD900000000017FE; - zrf = 64'h4020000100000006; - ans = 64'h40200204FFFFE009; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3956001\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h3FBFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3956615\n"); - end - xrf = 64'hBFECB2362DE0F377; - y = 64'hC7FFFFFFF00003FE; - zrf = 64'h4340000000000000; - ans = 64'h47FCB2361F87DBF5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3957229\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hBFE0000000000001; - zrf = 64'hC0EB2BD633D0A462; - ans = 64'hC0EB2BD233D0A462; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3957843\n"); - end - xrf = 64'hC4909D047E2E3993; - y = 64'h3FC0021FFFFFFFFE; - zrf = 64'hC1D029717C79EE32; - ans = 64'hC4609F3958C703C9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3958457\n"); - end - xrf = 64'h3FD3FFFFFFFFFDFF; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE9FFFFFFFFFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3959071\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h8011FFFFFFFBFFFF; - zrf = 64'hC0B0000000402000; - ans = 64'hC0B0000000402000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3959685\n"); - end - xrf = 64'hBFD0000007FFFBFF; - y = 64'hBFF0000000000000; - zrf = 64'h3F30000040020000; - ans = 64'h3FD00400080FFC7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3960299\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hC1F01FFFFFFFFFDF; - zrf = 64'h0000000000000000; - ans = 64'h41D01FFFFFFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3960913\n"); - end - xrf = 64'h4062E6BD1223E0B2; - y = 64'h37F0021FFFFFFFFF; - zrf = 64'h002C0007FFFFFFFF; - ans = 64'h3862E93FB7404975; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3961527\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h8010000000000000; - ans = 64'h3FDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3962141\n"); - end - xrf = 64'h80072CA6F5A92C4D; - y = 64'hB7EE00001FFFFFFF; - zrf = 64'h4010000000000001; - ans = 64'h4010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3962755\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hC000000000000000; - zrf = 64'h3FF0007FFFFFFFFB; - ans = 64'h3FF8007FFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3963369\n"); - end - xrf = 64'hC0139A6B29FE9D78; - y = 64'h4DEFFAFFFFFFFFFF; - zrf = 64'h421DFE0000000000; - ans = 64'hCE13975B09400DAF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3963983\n"); - end - xrf = 64'hBB4FFFFFFE000007; - y = 64'hC000000000000001; - zrf = 64'hBFD0000000000001; - ans = 64'hBFD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3964597\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h3E1000020003FFFF; - zrf = 64'h407EFFFFFFBFFFFF; - ans = 64'h407EFFFFFFBFEFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3965211\n"); - end - xrf = 64'hC8000007FFFFFEFF; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'hC03FFFFFFFDFFFE0; - ans = 64'h48200007FFFFFEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3965825\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h37E0000010000000; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3966439\n"); - end - xrf = 64'hBFEFFFFFFDFFFFDE; - y = 64'hFFEBFFFFFFFE0000; - zrf = 64'h3FB0800000000020; - ans = 64'h7FEBFFFFFE3DFFE2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3967053\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hC010000000000001; - zrf = 64'h8000000000000001; + z = 64'h3FF0000000000001; ans = 64'h3FF0000000000001; rn = 1; rz = 0; @@ -303725,19 +87147,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -303753,9271 +87175,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3967667\n"); + $fwrite(fp,"3733955\n"); end - xrf = 64'h29D0003F7FFFFFFF; - y = 64'hC3D05FFFFFFFFFFF; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h400FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3968281\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h41F9A49D2E0B0DFF; - ans = 64'h41F9A49D2E2B0DFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3968895\n"); - end - xrf = 64'hC280000FFEFFFFFF; - y = 64'h3FD0000FFFEFFFFE; - zrf = 64'h43DC00000000FFFF; - ans = 64'h43DBFFFFE000C001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3969509\n"); - end - xrf = 64'hC80679B587B79104; - y = 64'hC340000000000000; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h4B5679B587B79104; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3970123\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h5CC53197EE2C973A; - zrf = 64'h1AD0FF0000000000; - ans = 64'hDCA53197EE2C973A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3970737\n"); - end - xrf = 64'hC14F1FFFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hC3EF6FA933DE8BF0; - ans = 64'h44AF1E09056CC215; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3971351\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hBFB00000FDFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3971965\n"); - end - xrf = 64'hC80FFFFF7F7FFFFF; - y = 64'h279FFFFFBFFFFF80; - zrf = 64'hC06100000000003E; - ans = 64'hC06100000000003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3972579\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hFFE0000000000000; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3973193\n"); - end - xrf = 64'hBF60003FFFFFFFBF; - y = 64'h4320003EF7E4B7E8; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'hC290007EF8E08F3A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3973807\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h47F384676A9D2C88; - ans = 64'h7FCFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3974421\n"); - end - xrf = 64'h3D0FFFFFFFFC00FF; - y = 64'hB61FFFFFF0000007; - zrf = 64'hC078FFFFFFFFFFFF; - ans = 64'hC078FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3975035\n"); - end - xrf = 64'h3C0FFFFFFFFBBFFF; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'hFC0FFFFFFFFBBFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3975649\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hC0FB7ABF90C30569; - zrf = 64'hAA8003FFFFFFFFFA; - ans = 64'h40DB7ABF90C30569; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3976263\n"); - end - xrf = 64'h4974638EBBF64A3F; - y = 64'hFFF0000000000001; - zrf = 64'h00200080000FFFFF; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3976877\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'h07E47CFB53657A81; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3977491\n"); - end - xrf = 64'hC1BFFFEFFFEFFFFE; - y = 64'hBFEFFFFFFDFFF000; - zrf = 64'hBFBBFFFFFFFFF800; - ans = 64'h41BFFFEFFDD3F0FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3978105\n"); - end - xrf = 64'hBFD0000000000000; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3978719\n"); - end - xrf = 64'hC05FFFFFFFFF803F; - y = 64'hEA7FFF007FFFFFFF; - zrf = 64'h3FF0000000000000; - ans = 64'h6AEFFF007FFF8042; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3979333\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h0000000000000001; - zrf = 64'h41B8C52945BBFAB5; - ans = 64'h41B8C52945BBFAB5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3979947\n"); - end - xrf = 64'h090000000000000F; - y = 64'h8013DEB27E87ED71; - zrf = 64'h354FFEFFFFFFF000; - ans = 64'h354FFEFFFFFFF000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3980561\n"); - end - xrf = 64'h400FFFE000000010; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h8010000000000000; - ans = 64'h0027FFE00000000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3981175\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h39BFFFFE00000007; - zrf = 64'h40345ABEA176FD65; - ans = 64'h40345ABEA176FD65; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3981789\n"); - end - xrf = 64'hC02313215AE5236A; - y = 64'h0010000000000000; - zrf = 64'h380FFFFFFFC00000; - ans = 64'h380FFFFFFFC00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3982403\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h3FFEFFFFFFFFC000; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3983017\n"); - end - xrf = 64'hC3E00000003FBFFF; - y = 64'h3F900000002FFFFF; - zrf = 64'hBABB1E081B1414D0; - ans = 64'hC3800000006FBFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3983631\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3984245\n"); - end - xrf = 64'h7B4FFE0001FFFFFF; - y = 64'hB94FFFFFFFE0000F; - zrf = 64'h3FE0000000000001; - ans = 64'hF4AFFE0001E0020E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3984859\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hC80FFFDE00000000; - ans = 64'hC80FFFDE00000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3985473\n"); - end - xrf = 64'h43EFE0000007FFFF; - y = 64'h801B33C01CF5799F; - zrf = 64'h4036381A5D52DCFF; - ans = 64'h4036381A5D52DCFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3986087\n"); - end - xrf = 64'h3E3FFFEF00000000; - y = 64'h3CA0000000000001; - zrf = 64'h8000000000000001; - ans = 64'h3AEFFFEF00000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3986701\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hC2963A2744C815E7; - zrf = 64'h5770FFF800000000; - ans = 64'h5770FFF800000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3987315\n"); - end - xrf = 64'h002FFFFFEFFFFFF7; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h43C15567C6CBF43C; - ans = 64'h43C15567C6CBF43C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3987929\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h43F0040000000001; - zrf = 64'hC010000000000001; - ans = 64'hC3D0040000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3988543\n"); - end - xrf = 64'h41E67E7D7E29C6E8; - y = 64'h80113BE435615CD1; - zrf = 64'hC7EFFBFFFFFFBFFE; - ans = 64'hC7EFFBFFFFFFBFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3989157\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h3FD0000000000001; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3989771\n"); - end - xrf = 64'hC1C0008000001FFF; - y = 64'hC1E8B82EC582271A; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h43B8B8F486F8849A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3990385\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hC0001FFFFFEFFFFF; - ans = 64'hC0011FFFFFEFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3990999\n"); - end - xrf = 64'h3ED37FFFFFFFFFFE; - y = 64'hFFF5DF829A8187D2; - zrf = 64'h3FC00000001FFFFF; - ans = 64'hFFFDDF829A8187D2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3991613\n"); - end - xrf = 64'hBFA000007FFF7FFF; - y = 64'h3FE0000000000000; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3992227\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hC3E30BB4858318FD; - zrf = 64'h43D00000000010FE; - ans = 64'h43D985DA42C19D7D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3992841\n"); - end - xrf = 64'hCDAFFE00000001FE; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h3F1FFFFFFFC01FFF; - ans = 64'hCDAFFE00000001FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3993455\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h43FFFFFDFF000000; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC3DFFFFDFF000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3994069\n"); - end - xrf = 64'hB800000007FFFFFF; - y = 64'h7FDF5D2DD7E7752E; - zrf = 64'h40AF553D70AC8668; - ans = 64'hF7EF5D2DE7960C18; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3994683\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h3FF0000000000000; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h401EFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3995297\n"); - end - xrf = 64'hC80000000FDFFFFF; - y = 64'hC3DFFFFFFFFFFC0F; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h4BF000000FDFFE06; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3995911\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h3FF0000000000001; - zrf = 64'hBE8200001FFFFFFF; - ans = 64'hBFD0000090000102; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3996525\n"); - end - xrf = 64'h37EB27DD446055AC; - y = 64'h3CA0200000008000; - zrf = 64'h00120000001FFFFE; - ans = 64'h349B5E2CFEE9EF96; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3997139\n"); - end - xrf = 64'h41ED268E2DEAC13F; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3997753\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hBFE139D0B510463B; - zrf = 64'h417F800000000008; - ans = 64'h417F800002273A1F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3998367\n"); - end - xrf = 64'h47FFFFFFEFF7FFFE; - y = 64'h4000000000000000; - zrf = 64'h877000007FFFFFFF; - ans = 64'h480FFFFFEFF7FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3998981\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hC03007FFFDFFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'h40000FFFFC000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"3999595\n"); - end - xrf = 64'h40000000000000FF; - y = 64'h403FFFFFFFFFF00F; - zrf = 64'h3FDFFFFF7FFFFF7F; - ans = 64'h40501FFFFF7FF906; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4000209\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h4007FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4000823\n"); - end - xrf = 64'hC030400010000000; - y = 64'h43E80000000003FF; - zrf = 64'h3CA0000000000000; - ans = 64'hC42860001800040F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4001437\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h4010000000000000; - zrf = 64'h401FFFFFDFFFDFFF; - ans = 64'h401BFFFFDFFFDFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4002051\n"); - end - xrf = 64'hC80FFFFF40000000; - y = 64'hC2FFFDDFFFFFFFFE; - zrf = 64'hBFBFFE0FFFFFFFFF; - ans = 64'h4B1FFDDF400CBFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4002665\n"); - end - xrf = 64'h41EFFFFFFFDFFFDF; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4003279\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h403FFFFFFFC00FFF; - zrf = 64'h3FBBFFFFFBFFFFFE; - ans = 64'hC01F8FFFFFD01001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4003893\n"); - end - xrf = 64'h7FE0000000FFFFFE; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hBFC00007FFFFFFFB; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4004507\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hC1E168099A1FC31E; - zrf = 64'hBFF0000000000000; - ans = 64'h41C16809999FC31F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4005121\n"); - end - xrf = 64'hC0CBD59D6AA012B6; - y = 64'h41200000001FFEFF; - zrf = 64'h380FFFF0000FFFFE; - ans = 64'hC1FBD59D6AD7BC32; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4005735\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h4000000000000000; - ans = 64'hC32FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4006349\n"); - end - xrf = 64'hC0100020FFFFFFFE; - y = 64'hB3E00000000007FD; - zrf = 64'h0010000000000001; - ans = 64'h34000021000007FB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4006963\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hB810000000003FFF; - ans = 64'hC330000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4007577\n"); - end - xrf = 64'h470F7FE000000000; - y = 64'h47F41FFFFFFFFFFE; - zrf = 64'hB0EFFFFFFFFFFBFF; - ans = 64'h4F13CF6BDFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4008191\n"); - end - xrf = 64'h0010000008000FFE; - y = 64'h7FE0000000000001; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4008805\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h3FE416D104F099D3; - zrf = 64'h37F0000403FFFFFF; - ans = 64'hBFC416D104F099D4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4009419\n"); - end - xrf = 64'hB3BFFFFFFFFE0007; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hC020000002000001; - ans = 64'hF3BFFFFFFFFE0006; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4010033\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h43C1DB4D2B6309FB; - zrf = 64'hBFE0000000000001; - ans = 64'hC3A1DB4D2B6309FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4010647\n"); - end - xrf = 64'h4D6FFFFFFD000000; - y = 64'h801020000000000F; - zrf = 64'hC02000000007FFFE; - ans = 64'hC02000000007FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4011261\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h7FF0000000000001; - zrf = 64'h3FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4011875\n"); - end - xrf = 64'h8390000001FDFFFF; - y = 64'h41D00000800001FE; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h8570000081FE020D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4012489\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'hC0303C0000000000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4013103\n"); - end - xrf = 64'h3FB0000000FFFFE0; - y = 64'h4D600000020003FE; - zrf = 64'h3FCFFFFA00000000; - ans = 64'h4D200000030003DE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4013717\n"); - end - xrf = 64'hB81FFFC200000000; - y = 64'h8000000000000000; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h401FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4014331\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hB65BFFFEFFFFFFFF; - zrf = 64'h3F60007FFFFFFFF7; - ans = 64'h3F60007FFFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4014945\n"); - end - xrf = 64'h5E7FFFFFFFFFF900; - y = 64'h8000000000000001; - zrf = 64'h37FD80E342268EB7; - ans = 64'h37FD80E342268EB7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4015559\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h402FFFEFFFFFFFEE; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hC011FFF7FFFFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4016173\n"); - end - xrf = 64'hC342C8CD26F024C5; - y = 64'h3F8F6C22FCBDE80E; - zrf = 64'hFFD00000403FFFFE; - ans = 64'hFFD00000403FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4016787\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h8010000000000000; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4017401\n"); - end - xrf = 64'h000FFFFFFFF03FFE; - y = 64'hC03F8000000FFFFE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4018015\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h8010000000000001; - zrf = 64'hBDE04000000001FF; - ans = 64'hBDE04000000001FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4018629\n"); - end - xrf = 64'hC3E0FFFFFFFFFFF6; - y = 64'hC08FFFEFFFF7FFFE; - zrf = 64'hC25FFFFFFDBFFFFF; - ans = 64'h4480FFF77FF7BFF5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4019243\n"); - end - xrf = 64'h38000000000100FF; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4019857\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hC80FFFFFFFF00003; - zrf = 64'hCAD21510DDD222A9; - ans = 64'hCAD21510DDD22269; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4020471\n"); - end - xrf = 64'h43DFFFFEFFFFFFF8; - y = 64'hBCA0000000000000; - zrf = 64'h434FFFFFFFFFFFBF; - ans = 64'h434FFFFFFFFFFDBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4021085\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h402000000020FFFF; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hC000000000210001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4021699\n"); - end - xrf = 64'h47F0000000000000; - y = 64'hC00FF7FFFFBFFFFE; - zrf = 64'h406001FFFFFFFFF0; - ans = 64'hC80FF7FFFFBFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4022313\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4022927\n"); - end - xrf = 64'hC26FF7FFFFFFFFDF; - y = 64'hBE8FFFFFFFFBFFFD; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4023541\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hBFD0000000000000; - zrf = 64'hB8C00000000020FF; - ans = 64'h3FB0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4024155\n"); - end - xrf = 64'hC08E000003FFFFFF; - y = 64'hF9D00000087FFFFE; - zrf = 64'hC02489F7E6A8C0A1; - ans = 64'h7A6E000013EFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4024769\n"); - end - xrf = 64'h43C3E49A1538B476; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h4000000000000000; - ans = 64'hC3B3E49A1538B475; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4025383\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hC02FFFFFF7BFFFFF; - zrf = 64'hC01004003FFFFFFE; - ans = 64'hBF7001107FFFF600; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4025997\n"); - end - xrf = 64'h7FEFFFFFFFFEFFBF; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h414FFFFEFFFFBFFF; - ans = 64'hFFDFFFFFFFFEFFBD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4026611\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hB52C7FFFFFFFFFFF; - zrf = 64'hBCA0000000000000; - ans = 64'hBCA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4027225\n"); - end - xrf = 64'h3FAFFFFFF80007FE; - y = 64'hBEAFE00000000001; - zrf = 64'h0011FFFFFFFFFFFE; - ans = 64'hBE6FDFFFF80807F7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4027839\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h3FD0000000000000; - ans = 64'h3FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4028453\n"); - end - xrf = 64'hB80F000000000000; - y = 64'h35A00000403FFFFE; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4029067\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hB806C0503D591458; - ans = 64'h3FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4029681\n"); - end - xrf = 64'h401FFC0000000800; - y = 64'h6566473ABD074EDC; - zrf = 64'h4047FFFF7FFFFFFE; - ans = 64'h65964471D5AFB384; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4030295\n"); - end - xrf = 64'hBFF0800000000100; - y = 64'hBFF0000000000001; - zrf = 64'h3FF0000000000001; - ans = 64'h4000400000000081; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4030909\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h648FFFFFC00003FF; - zrf = 64'hD4400000FFFF7FFF; - ans = 64'hE46FFFFFC0000401; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4031523\n"); - end - xrf = 64'hC7F100000000003E; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h3800EFFFFFFFFFFE; - ans = 64'h480100000000003D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4032137\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hC1C08FFFFFFFFFFF; - zrf = 64'h8010000000000001; - ans = 64'h41A0900000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4032751\n"); - end - xrf = 64'h3FFFFFFEFFFEFFFF; - y = 64'h401003FFFFFDFFFF; - zrf = 64'hC0100FFFFFFF0000; - ans = 64'h400FEFFDFF77FF7A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4033365\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hC000000000000001; - zrf = 64'h3CA0000000000001; - ans = 64'h3FE0000000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4033979\n"); - end - xrf = 64'h41C00000001FFBFE; - y = 64'hC221001FFFFFFFFE; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC3F104200021FBFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4034593\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h7FD00004000FFFFF; - ans = 64'h7FD00004000FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4035207\n"); - end - xrf = 64'hC1C34B4A0CDF34C0; - y = 64'h47FFFFFFFFF7FFFE; - zrf = 64'h3FEFFFFFFFFFF03E; - ans = 64'hC9D34B4A0CDA61EC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4035821\n"); - end - xrf = 64'h47FB969279E5DD33; - y = 64'hC010000000000000; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'hC81B969279E5DD33; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4036435\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hBFB1C24320BB5D4C; - zrf = 64'hBD6021FFFFFFFFFF; - ans = 64'h3F91C24320B9590D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4037049\n"); - end - xrf = 64'h3D3000001FEFFFFE; - y = 64'hC010000000000001; - zrf = 64'hC2F000000FF00000; - ans = 64'hC2F000000FF00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4037663\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hB7E0000201000000; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h37C0000201000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4038277\n"); - end - xrf = 64'h40500003FFFFFFF7; - y = 64'hB81B09507F18BE9F; - zrf = 64'h43100000000000C0; - ans = 64'h43100000000000C0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4038891\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hC340000000000000; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h4320000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4039505\n"); - end - xrf = 64'h47EFFFE03FFFFFFF; - y = 64'h80000800007FFFFF; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4040119\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hC340000000000001; - zrf = 64'hBFEFFFFBFEFFFFFF; - ans = 64'h4320000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4040733\n"); - end - xrf = 64'h381000001FF7FFFF; - y = 64'hBEFFFFE00000003F; - zrf = 64'h37F00000000407FF; - ans = 64'h37EFFF0001061080; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4041347\n"); - end - xrf = 64'hC00FFE01FFFFFFFF; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h436FFE01FFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4041961\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h41DFFFFFFF7FFFFE; - zrf = 64'h3E1FBFFFF0000000; - ans = 64'hC1BFFFFFFF800000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4042575\n"); - end - xrf = 64'hBE5F58FE19AABA16; - y = 64'hFFE0000000000000; - zrf = 64'h7B8ABA52ABAF7E78; - ans = 64'h7E4F58FE19AABBC2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4043189\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hB64000004FFFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4043803\n"); - end - xrf = 64'hBFF00800000001FF; - y = 64'hBEA0000FFFFFFFFF; - zrf = 64'h3CA00000003FFFF7; - ans = 64'h3EA00810081001FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4044417\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h7FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4045031\n"); - end - xrf = 64'h47F01FFBFFFFFFFF; - y = 64'hC3CFFFBFFF000000; - zrf = 64'hC010000000000000; - ans = 64'hCBD01FDBBF87001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4045645\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'hFFF0000000000000; - zrf = 64'hCDF0083FFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4046259\n"); - end - xrf = 64'hC1F0000001FFFFF8; - y = 64'hF000091FCAE1C2F2; - zrf = 64'h40700000000FBFFF; - ans = 64'h7200091FCCE2E6E3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4046873\n"); - end - xrf = 64'h380BFFFFFFFBFFFF; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h3FD0000000000000; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4047487\n"); - end - xrf = 64'hBFD0000000000001; - y = 64'h4F5FFFEFFFFFEFFF; - zrf = 64'hBFEF00FFFFFFFFFF; - ans = 64'hCF3FFFEFFFFFF001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4048101\n"); - end - xrf = 64'h3FCFFFFFFDC00000; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h7FE00000001FFFDF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4048715\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h3957F80000000000; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4049329\n"); - end - xrf = 64'h80224267F356EFFA; - y = 64'h7FF1000003FFFFFF; - zrf = 64'h401040000000007F; - ans = 64'h7FF9000003FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4049943\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h0000000000000000; - ans = 64'h8007FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4050557\n"); - end - xrf = 64'h37EFFFBFFFFEFFFF; - y = 64'hB7FFDFFFFFFFFEFE; - zrf = 64'hC000000000000001; - ans = 64'hC000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4051171\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h427B3594CB0AE0F1; - ans = 64'h427B3594CB0AE0F1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4051785\n"); - end - xrf = 64'hB8100000037FFFFE; - y = 64'h4032B8ACAF198E6B; - zrf = 64'hC1AE1FFFFFFFFFFE; - ans = 64'hC1AE1FFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4052399\n"); - end - xrf = 64'h9EB000000020FFFF; - y = 64'h0010000000000001; - zrf = 64'h3CA0000000000001; - ans = 64'h3CA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4053013\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h402325F07518C19F; - zrf = 64'h3FAF0003FFFFFFFF; - ans = 64'hC012E7F06D18C19E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4053627\n"); - end - xrf = 64'hBFC0000000000140; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h41E0000000000030; - ans = 64'h41E0000000000030; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4054241\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'hBF5579030AA5CAAA; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4054855\n"); - end - xrf = 64'h45BC57DB7A30FEF8; - y = 64'hC1FFFFFFFDFFFFBF; - zrf = 64'h41DFFFFFFF800020; - ans = 64'hC7CC57DB786B8107; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4055469\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h3CA0000000000000; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4056083\n"); - end - xrf = 64'h41DFFFFFFFE00001; - y = 64'h8000010000100000; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4056697\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h41E000000010007F; - ans = 64'h41E000000010007F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4057311\n"); - end - xrf = 64'h05084F7999D9CDC4; - y = 64'hBEBE0D041AA7AD4D; - zrf = 64'h401000007FFFFFFC; - ans = 64'h401000007FFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4057925\n"); - end - xrf = 64'h540FF80200000000; - y = 64'h3FD0000000000000; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h53EFF80200000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4058539\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'hFFFDE9DA2A5BA63C; - zrf = 64'h479B42C807E21737; - ans = 64'hFFFDE9DA2A5BA63C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4059153\n"); - end - xrf = 64'h3E2FF7FF00000000; - y = 64'h3FD0000000000001; - zrf = 64'hBCAFFFFFBDFFFFFF; - ans = 64'h3E0FF7FE8000010A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4059767\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h001000200000000E; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4060381\n"); - end - xrf = 64'hC3CFDFFFFFFFFFFB; - y = 64'h401FFFFF800003FF; - zrf = 64'h3FFC31B98FE49BD5; - ans = 64'hC3FFDFFF808003F6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4060995\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4061609\n"); - end - xrf = 64'hBFEFFFFFFFC00040; - y = 64'h37FFFFFFF80000FE; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hBFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4062223\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h3FE0000000000001; - zrf = 64'hC0100007FFFFEFFF; - ans = 64'hC0110007FFFFEFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4062837\n"); - end - xrf = 64'hFFEFFFFE007FFFFF; - y = 64'hBFF00000040FFFFF; - zrf = 64'hC1A12616CF13226C; - ans = 64'h7FEFFFFE089FFF7B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4063451\n"); - end - xrf = 64'hD3744789209EB713; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'hD3744789209EB712; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4064065\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h802FFFFFFBFFFFF7; - zrf = 64'hC030001FFFFFFFFF; - ans = 64'hC030001FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4064679\n"); - end - xrf = 64'h43FFFFBFFFFF7FFF; - y = 64'h3FF0000000000000; - zrf = 64'hBAD007FFC0000000; - ans = 64'h43FFFFBFFFFF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4065293\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h401F000000001FFF; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h40107FFFFFFFEFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4065907\n"); - end - xrf = 64'h3CAFFFAFFFFFFFFF; - y = 64'h40C8BC8C8EDD1A1B; - zrf = 64'hBA8BBCC16EDFA2A4; - ans = 64'h3D88BC4EB77DB4D6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4066521\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4067135\n"); - end - xrf = 64'h480007FFFFFFFFFF; - y = 64'hC3E23B89425430FF; - zrf = 64'hBFE0000000000000; - ans = 64'hCBF244A706F55B16; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4067749\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h4000000000000000; - zrf = 64'hC80C200000000000; - ans = 64'hC80C200000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4068363\n"); - end - xrf = 64'hC3D000003FFFFFFA; - y = 64'hC001FBFFFFFFFFFF; - zrf = 64'hC3DFFFFF000003FE; - ans = 64'h43AFC00C7EFFDF94; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4068977\n"); - end - xrf = 64'hCDA0007FFFFF7FFE; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h0000000000000000; - ans = 64'hCDC0007FFFFF7FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4069591\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'hB7E0000007FDFFFF; - zrf = 64'hF06BFFFFFFFFFDFF; - ans = 64'hF06BFFFFFFFFFDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4070205\n"); - end - xrf = 64'h3FC6375007C0E6CB; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hBF80100200000000; - ans = 64'h3FE5F70FFFC0E6CA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4070819\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h3F800000000000FF; - zrf = 64'h4010000000000000; - ans = 64'h400FF80000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4071433\n"); - end - xrf = 64'hC2F505134A57C74A; - y = 64'hC4FDFFFDFFFFFFFE; - zrf = 64'h00036DB98B6B20DE; - ans = 64'h4803B4C0C561162F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4072047\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h4010000000000001; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4072661\n"); - end - xrf = 64'hC1D000001003FFFE; - y = 64'hE41628388A474A48; - zrf = 64'hBFD0000000000001; - ans = 64'h65F62838A0750CDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4073275\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hBFBD1E150B87BBA9; - ans = 64'hC0107478542E1EED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4073889\n"); - end - xrf = 64'h403000080000FFFF; - y = 64'hC11FFFFFFFFF7FBF; - zrf = 64'h3FD0000007FFF000; - ans = 64'hC1600007F800BFDA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4074503\n"); - end - xrf = 64'h402442B011FC172E; - y = 64'h4340000000000000; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4075117\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h92E5F946438B34BB; - zrf = 64'h3D98249F431F8AF7; - ans = 64'h3D98249F431F8AF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4075731\n"); - end - xrf = 64'h7FFD8D2187349BAF; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'hBFAFFFFFEFFFFFEF; - ans = 64'h7FFD8D2187349BAF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4076345\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h403FE01FFFFFFFFE; - zrf = 64'h4000000000000001; - ans = 64'hC02BE01FFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4076959\n"); - end - xrf = 64'hB61FF07FFFFFFFFE; - y = 64'hC1F1BFFFFFFFFFFF; - zrf = 64'h9EE00007FFFFFDFE; - ans = 64'h3821B766FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4077573\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h7FE0000000000000; - zrf = 64'hC010000000000001; - ans = 64'hFFCFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4078187\n"); - end - xrf = 64'h402FFFDFFFFFFFF0; - y = 64'h42B0000000204000; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h42EFFFE000407FAF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4078801\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h3FF2000007FFFFFF; - ans = 64'hFFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4079415\n"); - end - xrf = 64'hBFBFFFFFFFFFFFC4; - y = 64'h001FFF4000000000; - zrf = 64'h3FFFFFBFFF7FFFFF; - ans = 64'h3FFFFFBFFF7FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4080029\n"); - end - xrf = 64'hBFC3F41B293A86D3; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4080643\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'hC0D1AADED1EB7CD5; - zrf = 64'hBFD007FFFFFDFFFE; - ans = 64'h40C1AABEC1EB7CD8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4081257\n"); - end - xrf = 64'h7FEFFFFFFFF7EFFE; - y = 64'h7FF0000000000001; - zrf = 64'hC1FFFF7FFFFFFFFF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4081871\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'hC05FFFFFFFE7FFFF; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h40507FFFFFF3FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4082485\n"); - end - xrf = 64'h7FEF0001FFFFFFFF; - y = 64'h5E388880C29ADC6B; - zrf = 64'hBFC05BC428DD59D2; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4083099\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4083713\n"); - end - xrf = 64'h43FFFFFEFFFFFFDF; - y = 64'h3FD04007FFFFFFFE; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h43E040077DFFBFED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4084327\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h8000000000000001; - zrf = 64'h8010000000800400; - ans = 64'h8010000000800400; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4084941\n"); - end - xrf = 64'h43D00000000000BF; - y = 64'hF9FCA451E6B538F5; - zrf = 64'hCD0EA8DC36585668; - ans = 64'hFDDCA451E6B53A4B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4085555\n"); - end - xrf = 64'h40600001FF000000; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4086169\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h4030000000FFFFFB; - zrf = 64'h3CAFEFFFFFFFFDFF; - ans = 64'hC020000000FFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4086783\n"); - end - xrf = 64'h001FFBFFFFFFFFFB; - y = 64'h8010000000000000; - zrf = 64'hBFA00FDFFFFFFFFF; - ans = 64'hBFA00FDFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4087397\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h3F900000000EFFFF; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h3FEFBFFFFFFFC3FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4088011\n"); - end - xrf = 64'h8005FBF65B4CBC10; - y = 64'h41D0015FA92DD7E1; - zrf = 64'h4EBFFFFFFE000002; - ans = 64'h4EBFFFFFFE000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4088625\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; + x = 64'hF322908E1375DFCB; y = 64'h801FFFFFFFFFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hBFFFFFFFFFFFFFFE; + z = 64'h41F0000FFFFFFFFD; + ans = 64'h41F0000FFFFFFFFD; rn = 1; rz = 0; rm = 0; @@ -313031,19 +87194,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -313059,12 +87222,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4089239\n"); + $fwrite(fp,"3735969\n"); end - xrf = 64'hBD7000000000207F; - y = 64'h8EA0080000001000; - zrf = 64'h8010000000000000; - ans = 64'h0C2008000000308F; + x = 64'hC3F008000001FFFF; + y = 64'hC3FFFFFFFFFFEFFF; + z = 64'h800EFFFFFFFF7FFE; + ans = 64'h480008000001F7FA; rn = 1; rz = 0; rm = 0; @@ -313078,19 +87241,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -313106,105 +87269,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4089853\n"); + $fwrite(fp,"3737983\n"); end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'hBCA0000000000000; - zrf = 64'h80166B3DD617F693; - ans = 64'h3C8FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4090467\n"); - end - xrf = 64'hB81DAC55BF5BDFB4; - y = 64'hDCC38871CC23B0AF; - zrf = 64'h3CA0000007DFFFFF; - ans = 64'h54F21CD8DBE659FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4091081\n"); - end - xrf = 64'hA15FFFFFFF001FFF; - y = 64'hBCA0000000000001; - zrf = 64'hC340000000000000; + x = 64'hBCA0000000000001; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hC340000000000000; ans = 64'hC340000000000000; rn = 1; rz = 0; @@ -313219,19 +87288,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -313247,12 +87316,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4091695\n"); + $fwrite(fp,"3739997\n"); end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h0000000000000088; - zrf = 64'hF9B000007FDFFFFF; - ans = 64'hF9B000007FDFFFFF; + x = 64'hC6BFFFFFFDFFFFC0; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h4030200003FFFFFF; + ans = 64'h46AFFFFFFDFFFFBF; rn = 1; rz = 0; rm = 0; @@ -313266,19 +87335,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -313294,12 +87363,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4092309\n"); + $fwrite(fp,"3742011\n"); end - xrf = 64'h43E00001F7FFFFFF; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hB9E00000001FFFBF; - ans = 64'hC0A00001F7FFFFFE; + x = 64'hC250000000001FFF; + y = 64'h8722F954FDAE09DB; + z = 64'hC7FFFFFFFE3FFFFF; + ans = 64'hC7FFFFFFFE3FFFFF; rn = 1; rz = 0; rm = 0; @@ -313313,19 +87382,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -313341,3066 +87410,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4092923\n"); + $fwrite(fp,"3744025\n"); end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h541FFFFFFE0001FE; - zrf = 64'h3FE0000000000000; - ans = 64'hD40FFFFFFE0001FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4093537\n"); - end - xrf = 64'h39700004000007FE; - y = 64'h3800000800400000; - zrf = 64'h3FDB4AD36E04AA09; - ans = 64'h3FDB4AD36E04AA09; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4094151\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'hBFD0000000000001; - zrf = 64'hBFF0000000000000; - ans = 64'hBFEC000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4094765\n"); - end - xrf = 64'h43EFFFFE0000000E; - y = 64'hBFEFFFFFFFFFFE07; - zrf = 64'h8000000000000001; - ans = 64'hC3EFFFFDFFFFFE15; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4095379\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'hBFCFFFBFFFFF7FFF; - ans = 64'h3EE000001FFF8000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4095993\n"); - end - xrf = 64'hB87003FFFFFFFFFE; - y = 64'h402FFFFEFFEFFFFF; - zrf = 64'hC3EFFC00007FFFFF; - ans = 64'hC3EFFC00007FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4096607\n"); - end - xrf = 64'h40F0000000100200; - y = 64'hBFE0000000000000; - zrf = 64'hC010000000000001; - ans = 64'hC0E0008000100200; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4097221\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'hC066FFFFFFFFFFFF; - zrf = 64'h3FDF4B5441BBD2DA; - ans = 64'h40571F4B5441BBD1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4097835\n"); - end - xrf = 64'h41F000001000000F; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h2000100003FFFFFE; - ans = 64'hC1F000001000000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4098449\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h3FDF1F3616AA73E1; - zrf = 64'h3FD0000000000001; - ans = 64'h3F7C193D2AB1843F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4099063\n"); - end - xrf = 64'h41B21BEA7A76E93C; - y = 64'hC3F000000000041E; - zrf = 64'hB7EFFFFFFFFFFDF7; - ans = 64'hC5B21BEA7A76EDE5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4099677\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'hBFF0000000000000; - zrf = 64'hBFE0000000000001; - ans = 64'hBCA8000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4100291\n"); - end - xrf = 64'hC03AE281F17C5475; - y = 64'h75B0000001004000; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4100905\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h3FB66ECB6E4046E4; - ans = 64'h3FF166ECB6E4046D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4101519\n"); - end - xrf = 64'h92F0515EB07C07FC; - y = 64'h37FFFFFFFFFF3FFE; - zrf = 64'h40DFFFFFFFFFEFBE; - ans = 64'h40DFFFFFFFFFEFBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4102133\n"); - end - xrf = 64'h44401FFFFFFFEFFF; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC4501FFFFFFFEFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4102747\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'hC80FE7FFFFFFFFFE; - zrf = 64'hBFB00FEFFFFFFFFF; - ans = 64'h47FFE7FFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4103361\n"); - end - xrf = 64'hBF6FFFFFFFFFFFFF; - y = 64'hC000000000000001; - zrf = 64'hC3D3FFFFDFFFFFFE; - ans = 64'hC3D3FFFFDFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4103975\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h42EFFFFFFBF7FFFF; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hC2DFFFFFFBF7FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4104589\n"); - end - xrf = 64'h0897CEC85B51437D; - y = 64'h401FFF6FFFFFFFFE; - zrf = 64'h403A4A17E844BFB1; - ans = 64'h403A4A17E844BFB1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4105203\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'h3FF7FFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4105817\n"); - end - xrf = 64'h00207FFFFFF80000; - y = 64'h43E00001FFFBFFFE; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4106431\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'hC010000000000001; - zrf = 64'h074CFFFFFFFFFFFF; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4107045\n"); - end - xrf = 64'hBFE0003FFEFFFFFF; - y = 64'hC34B8B33D83E1B8C; - zrf = 64'hB4E0004000001000; - ans = 64'h433B8BA20354C945; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4107659\n"); - end - xrf = 64'hC3400000001000FE; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'h43700000001000FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4108273\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h41DFFFFFFFFC0200; - zrf = 64'hC80FFFF800000003; - ans = 64'hC80FFFF800000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4108887\n"); - end - xrf = 64'h400E0007FFFFFFFF; - y = 64'hC340000000000000; - zrf = 64'h9C6FFFFC00100000; - ans = 64'hC35E0007FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4109501\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'hBF1BD53EFA18504A; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h3F0BD53EFA185049; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4110115\n"); - end - xrf = 64'hFF4FE00007FFFFFF; - y = 64'hFFE800001FFFFFFF; - zrf = 64'hC01FFFFFDEFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4110729\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'h433FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4111343\n"); - end - xrf = 64'h3FFFFFFFDFFF0000; - y = 64'h4F1FFFFFFFFFC002; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4111957\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'hFFE0000000000000; - zrf = 64'hC03F3FFFFFFFFFFF; - ans = 64'h7FCFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4112571\n"); - end - xrf = 64'h31FFFFFFFF07FFFF; - y = 64'hFFEFFF7FFFFFFFFE; - zrf = 64'h3FF011FFFFFFFFFF; - ans = 64'hF1FFFF7FFF0803DD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4113185\n"); - end - xrf = 64'h381A95466807D9F0; - y = 64'hFFE0000000000001; - zrf = 64'hBFF0000000000000; - ans = 64'hF80A95466807D9F2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4113799\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'hBFFD54CBF34AE708; - zrf = 64'h3F1FFFFFFF7FFFFA; - ans = 64'h3FED55CBF34AE307; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4114413\n"); - end - xrf = 64'h0012A8DA247AE7B5; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h3E62C8F75B319572; - ans = 64'hC012A8DA2221C8C8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4115027\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'h3FD000000FFFFFFA; - zrf = 64'h0010000000000000; - ans = 64'hBFC000000FFFFFF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4115641\n"); - end - xrf = 64'h43CE712777B7B02E; - y = 64'h7CC08FFFFFFFFFFF; - zrf = 64'hBFC000003FFFFFFD; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4116255\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'hFFF0000000000001; - zrf = 64'hBCA0000000000000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4116869\n"); - end - xrf = 64'hBDC00FFFFFFFFDFE; - y = 64'h43EFFFFFF0000008; - zrf = 64'h4340000000000001; - ans = 64'h433FFFFFDFE00012; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4117483\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFF; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'hBE1F000000000020; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4118097\n"); - end - xrf = 64'hC07FFFFFFFF7FFDF; - y = 64'h3E377B7BD3144DB7; - zrf = 64'h40307FFFFFFBFFFF; - ans = 64'h40307FFFD1050859; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4118711\n"); - end - xrf = 64'h41FFFFF000800000; - y = 64'h0000000000000000; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4119325\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h4030000000FFFFBF; - zrf = 64'h405003FFFBFFFFFF; - ans = 64'h404C07FFF7C0000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4119939\n"); - end - xrf = 64'hBC4FFFFFE000000F; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h8003FFFBFFFFFFFF; - ans = 64'h8003FFFBFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4120553\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hC7FFFF0000FFFFFF; - zrf = 64'h0000000000000001; - ans = 64'h47EFFF0000FFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4121167\n"); - end - xrf = 64'h402732530BB70658; - y = 64'hC3DC7AF74D5C1AAE; - zrf = 64'hDCBFFFFFFFFFBF80; - ans = 64'hDCBFFFFFFFFFBF80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4121781\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h0010000000000000; - zrf = 64'h8010000000000001; - ans = 64'h8018000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4122395\n"); - end - xrf = 64'h403A10A312D973AF; - y = 64'hBF3000000002007F; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h401FF97BD73B48D1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4123009\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h47F01FFFFFFEFFFF; - ans = 64'h47F01FFFFFFEFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4123623\n"); - end - xrf = 64'h3FBFFFFEFFFFFFFC; - y = 64'hCD90000000000402; - zrf = 64'h801003FFFFFDFFFE; - ans = 64'hCD5FFFFF00000800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4124237\n"); - end - xrf = 64'h37FCC30068FA9D44; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4124851\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hC030000000017FFF; - zrf = 64'hC060000000030000; - ans = 64'hC05E00000005D000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4125465\n"); - end - xrf = 64'h400FFFFFFE7FFFFE; - y = 64'h3CA0000000000001; - zrf = 64'hC7E8F1D8AFEC8A8B; - ans = 64'hC7E8F1D8AFEC8A8B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4126079\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h34CFFFFFFFBF8000; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4126693\n"); - end - xrf = 64'h002FFF7FFFFFFF7F; - y = 64'h73CFFFFFBFFFC000; - zrf = 64'hBF8FF800001FFFFF; - ans = 64'hBF8FF800001FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4127307\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'hBC9FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4127921\n"); - end - xrf = 64'hC1E40000000FFFFF; - y = 64'hC3E0000007FFFFFF; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h45D400000A0FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4128535\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h3FD0000000000001; - zrf = 64'hFFFFFFFFFFFFFF06; - ans = 64'hFFFFFFFFFFFFFF06; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4129149\n"); - end - xrf = 64'hC1F63AE7B64D7638; - y = 64'h3FC0003FFFFFFDFF; - zrf = 64'h3F8FF7FFBFFFFFFF; - ans = 64'hC1C63B40A1EA4D25; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4129763\n"); - end - xrf = 64'hB79163F77CC13082; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hBCAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4130377\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hC010000020000004; - zrf = 64'hBFF82FD4F08947C0; - ans = 64'h3FDF40AD3DDAE118; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4130991\n"); - end - xrf = 64'h3E70000000407FFF; - y = 64'h3FE0000000000000; - zrf = 64'hBFDFFFFFFF6FFFFE; - ans = 64'hBFDFFFFFDF6FFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4131605\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hFFE7FF0000000000; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFE4007FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4132219\n"); - end - xrf = 64'hBFCFE000000FFFFE; - y = 64'h390FFFFE000007FE; - zrf = 64'hC0E3FF09A5A6E1CF; - ans = 64'hC0E3FF09A5A6E1CF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4132833\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h7FFFFFFFFFFFFFFE; + x = 64'hBCA0000000000001; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -316415,19 +87429,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -316443,12 +87457,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4133447\n"); + $fwrite(fp,"3746039\n"); end - xrf = 64'h3A8FC000FFFFFFFF; - y = 64'h59DFBFFFFFFFFFFD; - zrf = 64'h4000000000000000; - ans = 64'h547F8080FDFFFFFC; + x = 64'hF3AFDFFFFEFFFFFF; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hC09FFFFFB7FFFFFF; + ans = 64'h73BFDFFFFEFFFFFE; rn = 1; rz = 0; rm = 0; @@ -316462,19 +87476,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -316490,12 +87504,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4134061\n"); + $fwrite(fp,"3748053\n"); end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h3FF0000000000000; - zrf = 64'hC00FFF9FFFFFFFFF; - ans = 64'hC011FFCFFFFFFFFF; + x = 64'h0000FFFFBFFFFFFF; + y = 64'h14E13CBB39ACD32D; + z = 64'hB7E000000007FFFB; + ans = 64'hB7E000000007FFFB; rn = 1; rz = 0; rm = 0; @@ -316509,19 +87523,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -316537,3114 +87551,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4134675\n"); + $fwrite(fp,"3750067\n"); end - xrf = 64'hC7F00000400001FF; - y = 64'h4020000000000300; - zrf = 64'hB525C7C381596E36; - ans = 64'hC8200000400004FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4135289\n"); - end - xrf = 64'hC3C000003FFE0000; - y = 64'h3FF0000000000001; - zrf = 64'hBCA0000000000000; - ans = 64'hC3C000003FFE0001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4135903\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h3AA05FFFFFFFFFFE; - zrf = 64'h3FE8281B1422E52E; - ans = 64'h3FE8281B1422E52E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4136517\n"); - end - xrf = 64'hAB5FFFFFFFFFFFDC; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hC08FFC0000000003; - ans = 64'hC08FFC0000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4137131\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hBFE0008000000FFE; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4137745\n"); - end - xrf = 64'hC3400000000007EF; - y = 64'h3CAFFEFFFFFFFF7F; - zrf = 64'hFFD0080000040000; - ans = 64'hFFD0080000040000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4138359\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h4000000000000001; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4138973\n"); - end - xrf = 64'hBFF44581EA6D56EC; - y = 64'h400FFE00000001FF; - zrf = 64'h3FF0000000000001; - ans = 64'hC010443D924EB15A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4139587\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hC3C0080007FFFFFF; - ans = 64'hC3C0080007FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4140201\n"); - end - xrf = 64'hC800000000800003; - y = 64'hC34FFFFFEFFFBFFF; - zrf = 64'h5E0E000000004000; - ans = 64'h5E0E000000004000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4140815\n"); - end - xrf = 64'hCC04AF2E86BD6840; - y = 64'h4010000000000000; - zrf = 64'h8010000000000001; - ans = 64'hCC24AF2E86BD6840; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4141429\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hB13FFFFEFFFFFFEF; - zrf = 64'h802080000000FFFF; - ans = 64'h312FFFFEFFFFFFED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4142043\n"); - end - xrf = 64'h20CFFFFEBFFFFFFE; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h3B8000000013FFFF; - ans = 64'h3B8000000013FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4142657\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hF57FFFFF00000003; - zrf = 64'hC340000000000001; - ans = 64'h756FFFFF00000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4143271\n"); - end - xrf = 64'h3F90020400000000; - y = 64'h40ED533E77181CA7; - zrf = 64'h455FFFFFFBFEFFFF; - ans = 64'h455FFFFFFBFEFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4143885\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h4340000000000000; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4144499\n"); - end - xrf = 64'hFFFFC000007FFFFF; - y = 64'hC000007FFFFFFBFF; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'hFFFFC000007FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4145113\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h4340000000000001; - zrf = 64'hC7AFFFFFFFFFFEF0; - ans = 64'hC7AFFFFFFFFFFEF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4145727\n"); - end - xrf = 64'h434FFFFFFFFFFFC4; - y = 64'hCEDFF7FFFF7FFFFE; - zrf = 64'h3F0E00000000FFFF; - ans = 64'hD23FF7FFFF7FFFC2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4146341\n"); - end - xrf = 64'hBE003FFFF7FFFFFF; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'hC1603FFFF7FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4146955\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h4060000100FFFFFF; - zrf = 64'hBC022C12FDBE2841; - ans = 64'hC050000100FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4147569\n"); - end - xrf = 64'h7FD603AB6DC224B4; - y = 64'h7FE0000000000001; - zrf = 64'h3FEFC00000000002; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4148183\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h3CA0000000107FFE; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4148797\n"); - end - xrf = 64'h3FE010000003FFFE; - y = 64'hBD5FFFFFFFFFF07F; - zrf = 64'h3F6FFFFFFE01FFFF; - ans = 64'h3F6FFFFFFDF9F7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4149411\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'hFFDFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4150025\n"); - end - xrf = 64'h4020000000207FFE; - y = 64'h3FCC0000000FFFFE; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h4002000000246FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4150639\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h7FF0000000000000; - zrf = 64'h4033744DBD7C3789; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4151253\n"); - end - xrf = 64'hBF71008000000000; - y = 64'hC3F000080000001F; - zrf = 64'hC3E00000F7FFFFFF; - ans = 64'hC3DFBBFFCDFEFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4151867\n"); - end - xrf = 64'hC030000000000007; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h7FFFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4152481\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hBFD003FDFFFFFFFF; - zrf = 64'h3CE000000201FFFF; - ans = 64'h3FC003FE0000003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4153095\n"); - end - xrf = 64'h41D4D2099A1A1D11; - y = 64'h8000000000000000; - zrf = 64'hC01FFFF7FFFFF000; - ans = 64'hC01FFFF7FFFFF000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4153709\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hC030001FFFFFFF7F; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'h4010003FFFFFFEFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4154323\n"); - end - xrf = 64'h3FE000007F000000; - y = 64'h43E00000001FFC00; - zrf = 64'hB80C4B754170558B; - ans = 64'h43D000007F1FFC01; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4154937\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h401FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4155551\n"); - end - xrf = 64'hBF4400001FFFFFFE; - y = 64'hC020000040003FFE; - zrf = 64'h3FD0000000000000; - ans = 64'h3FD0500001C00142; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4156165\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'hC023FFFFFFFFEFFF; - ans = 64'hC023FFFFFFFFEFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4156779\n"); - end - xrf = 64'h47F00007FBFFFFFF; - y = 64'hC120003FFFFFFFFD; - zrf = 64'h3F4FFFFFFBFFFFF0; - ans = 64'hC9200047FC1FEFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4157393\n"); - end - xrf = 64'h41DFFFE0000000FF; - y = 64'h8010000000000001; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4158007\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hC036E81980A2CF56; - zrf = 64'h3FECCDBB4FDC39B1; - ans = 64'h4028B4F535A092F0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4158621\n"); - end - xrf = 64'hC05007FFFFFDFFFE; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h4380000840000000; - ans = 64'h4380000840000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4159235\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h41DFFFFFFFF7FBFE; - zrf = 64'hC000000000000000; - ans = 64'hC1D00000007BFDFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4159849\n"); - end - xrf = 64'h3FFFFFE800000000; - y = 64'h3FB18B9DEBEE5918; - zrf = 64'hC04FFFFFFFFFFFEA; - ans = 64'hC04FEE746F3CC802; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4160463\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hBCA0000000000001; - zrf = 64'h4010000000000000; - ans = 64'h4010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4161077\n"); - end - xrf = 64'hC0A01FFFFFBFFFFF; - y = 64'hB800020000010000; - zrf = 64'h3CA0000000000001; - ans = 64'h3CA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4161691\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'hC2FFFFE00007FFFE; - ans = 64'hC2FFFFE00007FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4162305\n"); - end - xrf = 64'h43DFFBFDFFFFFFFF; - y = 64'h3EA0000000004040; - zrf = 64'h8000000420000000; - ans = 64'h428FFBFE0000806F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4162919\n"); - end - xrf = 64'hC7FFFFF7FFFFFFFE; - y = 64'hBFD0000000000000; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4163533\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h7FEC13EF9199434E; - zrf = 64'h000FFFFFF7FEFFFF; - ans = 64'hFFDC13EF9199434C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4164147\n"); - end - xrf = 64'hBF0801FFFFFFFFFF; - y = 64'hBFD0000000000001; - zrf = 64'hACFFC007FFFFFFFF; - ans = 64'h3EE8020000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4164761\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hC7FACB56E7BA3FCD; - zrf = 64'hBFF0000000000001; - ans = 64'h47EACB56E7BA3FCB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4165375\n"); - end - xrf = 64'h38082D04D659F6FA; - y = 64'h3F0000080000000F; - zrf = 64'hC01FFFDFFFFDFFFF; - ans = 64'hC01FFFDFFFFDFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4165989\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hBFE0000000000000; - zrf = 64'h4000000000000001; - ans = 64'h4002000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4166603\n"); - end - xrf = 64'h654000000F7FFFFF; - y = 64'hC02001FFFFFFFFF6; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'hE57002000F81EFF5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4167217\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hBFE0000000000001; - zrf = 64'h3F80043FFFFFFFFE; - ans = 64'h3FD0802200000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4167831\n"); - end - xrf = 64'hC00FFFFFFFE1FFFF; - y = 64'h46E87DD4F55043F5; - zrf = 64'h3FE3DC5D89B1E043; - ans = 64'hC7087DD4F5394DFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4168445\n"); - end - xrf = 64'hBFF400003FFFFFFE; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h4350000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4169059\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h413FFFFFFFFFF80F; - zrf = 64'hF8900000000001EF; - ans = 64'hF8900000000001EF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4169673\n"); - end - xrf = 64'h47EFFFFFFFF07FFF; - y = 64'hBFF0000000000000; - zrf = 64'hBF70000027FFFFFE; - ans = 64'hC7EFFFFFFFF07FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4170287\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hBF90000010000001; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFEFBFFFFFBFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4170901\n"); - end - xrf = 64'hBFBDFFFFFFFFFBFF; - y = 64'h4011000800000000; - zrf = 64'h41F003FFFFFFFFDF; - ans = 64'h41F003FFFFF807DB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4171515\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h4007FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4172129\n"); - end - xrf = 64'hC1E07FBFFFFFFFFF; - y = 64'hBFFFFFFFFFE0001F; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h41F07FBFFFEF804F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4172743\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hC000000000000000; - zrf = 64'h90C8D770CF8A116C; - ans = 64'h3FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4173357\n"); - end - xrf = 64'hFFDFFFFDF7FFFFFF; - y = 64'hC01693598184F691; - zrf = 64'h3CA500FF9C3C2325; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4173971\n"); - end - xrf = 64'h935FFFFFFFFF0008; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h401FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4174585\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h3900007FFDFFFFFF; - zrf = 64'hC0B2B934191E9FD7; - ans = 64'hC0B2B934191E9FD7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4175199\n"); - end - xrf = 64'h41DFFFFFFFFFBFEE; + x = 64'hBCA0000000000001; y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h4290000080001FFF; - ans = 64'h428FF0010000401E; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CC8000000000000; rn = 1; rz = 0; rm = 0; @@ -319658,19 +87570,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -319686,12 +87598,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4175813\n"); + $fwrite(fp,"3752081\n"); end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h7FDCE070E8A2FA98; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hFFCCE070E8A2FA96; + x = 64'hB80FFFDFFFFBFFFF; + y = 64'hC010000000000001; + z = 64'hBFCFFFFFFFFFEFF7; + ans = 64'hBFCFFFFFFFFFEFF7; rn = 1; rz = 0; rm = 0; @@ -319705,19 +87617,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -319733,12 +87645,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4176427\n"); + $fwrite(fp,"3754095\n"); end - xrf = 64'h3FF0000101FFFFFE; - y = 64'h443F7FFFFFF7FFFE; - zrf = 64'hFFFFFFFC00000400; - ans = 64'hFFFFFFFC00000400; + x = 64'hBFB0750627ECE045; + y = 64'hC3D94D7190159B0A; + z = 64'h78FFFFFFBFFFFFF7; + ans = 64'h78FFFFFFBFFFFFF7; rn = 1; rz = 0; rm = 0; @@ -319752,19 +87664,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -319780,294 +87692,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4177041\n"); + $fwrite(fp,"3756109\n"); end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h4013FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4177655\n"); - end - xrf = 64'h801FF7FFFFFE0000; - y = 64'h409FFFF7FFFFBFFF; - zrf = 64'h0000000000000000; - ans = 64'h80CFF7F801FDC010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4178269\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h4190000007FFFFEF; - ans = 64'h4190000017FFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4178883\n"); - end - xrf = 64'h802FFFFDFFFDFFFE; - y = 64'hB80FFBFFFBFFFFFE; - zrf = 64'h5BD3985EB294C579; - ans = 64'h5BD3985EB294C579; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4179497\n"); - end - xrf = 64'hBB90000001BFFFFF; - y = 64'hC340000000000001; - zrf = 64'h4010000000000000; - ans = 64'h4010000200000038; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4180111\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'h6E4F0001FFFFFFFF; - zrf = 64'hC380000FFFFFFFEE; - ans = 64'hEE3F0001FFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4180725\n"); - end - xrf = 64'hC0DE000007FFFFFF; + x = 64'hBCA0000000000001; y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h401000000001FF00; - ans = 64'h443E000007FFFFFE; + z = 64'hBFF0000000000001; + ans = 64'h3FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -320081,19 +87711,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -320109,293 +87739,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4181339\n"); + $fwrite(fp,"3758123\n"); end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hC7EA66E56AFE1DEC; - zrf = 64'hBFD0000000000000; - ans = 64'h47DA66E56AFE1DEA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4181953\n"); - end - xrf = 64'hBFF000FFFFFFFE00; - y = 64'h800FFFF0000003FF; - zrf = 64'hBFE42E940C67FBEE; - ans = 64'hBFE42E940C67FBEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4182567\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; + x = 64'h43E93C2A6A97D86C; y = 64'hFFE0000000000001; - zrf = 64'h3FE0000000000000; - ans = 64'h7FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4183181\n"); - end - xrf = 64'hADB0000FFFFFFFFC; - y = 64'hC02EEBF51FC02CDC; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4183795\n"); - end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h5C200000007FFFFE; - ans = 64'h7FDFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4184409\n"); - end - xrf = 64'h43E008000000001F; - y = 64'hBFD000000FFFFEFF; - zrf = 64'h802FFFFE000000FF; - ans = 64'hC3C008001007FF1D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4185023\n"); - end - xrf = 64'h767BD7B7D1D2FD83; - y = 64'hFFF0000000000000; - zrf = 64'h4000000000000001; + z = 64'h43EFFFE000000004; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -320410,19 +87758,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -320438,12 +87786,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4185637\n"); + $fwrite(fp,"3760137\n"); end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hC01001FFF0000000; - zrf = 64'hDFD0362CEA892DAC; - ans = 64'hDFD0362CEA892DAC; + x = 64'hBFBFFFFFDFFFFDFE; + y = 64'h3F9C15102BF20E67; + z = 64'hFFF000400003FFFE; + ans = 64'hFFF800400003FFFE; rn = 1; rz = 0; rm = 0; @@ -320457,19 +87805,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -320485,12 +87833,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4186251\n"); + $fwrite(fp,"3762151\n"); end - xrf = 64'hC02F800000000100; - y = 64'hFFF0000000000001; - zrf = 64'h37F495A0415BAE18; - ans = 64'hFFF8000000000001; + x = 64'hBCA0000000000001; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'hFFFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -320504,19 +87852,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -320532,106 +87880,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4186865\n"); + $fwrite(fp,"3764165\n"); end - xrf = 64'hBFDFFFFFFFFFFFFE; - y = 64'hB3F18B7E6EE40FD8; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4187479\n"); - end - xrf = 64'hC0300000000100FF; - y = 64'h392DFFFFFFFFFFFF; - zrf = 64'hEEEF9E530B26B54B; - ans = 64'hEEEF9E530B26B54B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4188093\n"); - end - xrf = 64'hBFE0000000000000; + x = 64'h4B4396F138542460; y = 64'h0000000000000000; - zrf = 64'h3FD0000000000001; - ans = 64'h3FD0000000000001; + z = 64'h430000000FFFFDFF; + ans = 64'h430000000FFFFDFF; rn = 1; rz = 0; rm = 0; @@ -320645,19 +87899,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -320673,12 +87927,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4188707\n"); + $fwrite(fp,"3766179\n"); end - xrf = 64'hC00F000000000007; - y = 64'h733FFFFFF000001F; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; + x = 64'h453FFFFFFFFDFFFB; + y = 64'h3F41FFFFFF7FFFFE; + z = 64'h355000001FF7FFFF; + ans = 64'h4491FFFFFF7EDFFB; rn = 1; rz = 0; rm = 0; @@ -320692,19 +87946,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -320720,12 +87974,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4189321\n"); + $fwrite(fp,"3768193\n"); end - xrf = 64'hBFE0000000000000; - y = 64'h0000000000000001; - zrf = 64'hB42FFFFFFFEFFFF0; - ans = 64'hB42FFFFFFFEFFFF0; + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h0010000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -320739,19 +87993,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -320767,12 +88021,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4189935\n"); + $fwrite(fp,"3770207\n"); end - xrf = 64'hBFF001FFFFFBFFFF; - y = 64'hC960300000000000; - zrf = 64'hD742B1E79938E69F; - ans = 64'hD742B1E79938E69F; + x = 64'hC7EBE6A82D837A1D; + y = 64'h3CA0000000000000; + z = 64'h3FBFFF7FFF7FFFFF; + ans = 64'hC49BE6A82D837A1D; rn = 1; rz = 0; rm = 0; @@ -320786,19 +88040,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -320814,12 +88068,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4190549\n"); + $fwrite(fp,"3772221\n"); end - xrf = 64'h37EFFFFFFFFFFF7D; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFF; + x = 64'h43E1000000040000; + y = 64'hBFB8B76BCDCA5E1B; + z = 64'h3FDFFFFFFFFF01FE; + ans = 64'hC3AA42E28AAD31D8; rn = 1; rz = 0; rm = 0; @@ -320833,19 +88087,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -320861,12 +88115,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4191163\n"); + $fwrite(fp,"3774235\n"); end - xrf = 64'hBFE0000000000000; - y = 64'h3B3FFFFFFFFFDBFF; - zrf = 64'h41F0100020000000; - ans = 64'h41F0100020000000; + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h3FD0000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCB4000000000000; rn = 1; rz = 0; rm = 0; @@ -320880,19 +88134,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -320908,12 +88162,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4191777\n"); + $fwrite(fp,"3776249\n"); end - xrf = 64'h43FB43FE8BC8FF86; - y = 64'h0010000000000000; - zrf = 64'hC3D6ADE09121DE6F; - ans = 64'hC3D6ADE09121DE6F; + x = 64'h43F001FFFFEFFFFF; + y = 64'h3FE0000000000000; + z = 64'hC7F1FBFFFFFFFFFF; + ans = 64'hC7F1FBFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -320927,19 +88181,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -320955,12 +88209,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4192391\n"); + $fwrite(fp,"3778263\n"); end - xrf = 64'hBFE0000000000000; - y = 64'hC3F2080000000000; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h43E2080000000000; + x = 64'hC1D0080000000800; + y = 64'h7FEFFFFC0000007F; + z = 64'hC80FFFBFFFFFDFFE; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -320974,19 +88228,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -321002,12 +88256,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4193005\n"); + $fwrite(fp,"3780277\n"); end - xrf = 64'hC4AFFBFFFFFFEFFF; - y = 64'h3F7DFFFFFFFFBFFE; - zrf = 64'h3D235F3DFC9809FA; - ans = 64'hC43DFC3FFFFFB105; + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h3FF0000000000001; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -321021,19 +88275,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -321049,11 +88303,387 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4193619\n"); + $fwrite(fp,"3782291\n"); end - xrf = 64'hBFE0000000000000; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h3CAFFFFFFFFFFFFF; + x = 64'hC0C1001FFFFFFFFF; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hF8AFFFFFFFFFEF7F; + ans = 64'hF8AFFFFFFFFFEF7F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3784305\n"); + end + x = 64'hC3407FFFFEFFFFFF; + y = 64'hBFB9A56ED8CC7A8B; + z = 64'hC26080000000003F; + ans = 64'h430A6E7A4DF88770; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3786319\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h4010000000000000; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3788333\n"); + end + x = 64'h7FDFDFFFFFF7FFFF; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h2251FB2DDFC8CEA1; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3790347\n"); + end + x = 64'hC2BF048ED04E91D1; + y = 64'h402000000FFFFDFF; + z = 64'h4CF04000000007FF; + ans = 64'h4CF04000000007FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3792361\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h7FE0000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3794375\n"); + end + x = 64'h3D50000000F7FFFF; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hC022000000001FFF; + ans = 64'h7D50000000F7FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3796389\n"); + end + x = 64'hBFEFDFF7FFFFFFFF; + y = 64'hB39000007BFFFFFF; + z = 64'h3FCFF000001FFFFF; + ans = 64'h3FCFF000001FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3798403\n"); + end + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h8000000000000000; + z = 64'h3CAFFFFFFFFFFFFF; ans = 64'h3CAFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -321068,19 +88698,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -321096,2362 +88726,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4194233\n"); + $fwrite(fp,"3800417\n"); end - xrf = 64'hFFD00000000007FA; - y = 64'h0012DC494FF452A2; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4194847\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h3CA0000000000000; - zrf = 64'hDFE080007FFFFFFF; - ans = 64'hDFE080007FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4195461\n"); - end - xrf = 64'hBE00FFFFFFFEFFFF; - y = 64'hBFCFFFFFFC003FFF; - zrf = 64'h3CAFFFFFFFFF7FFE; - ans = 64'h3DE10001FDDF21FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4196075\n"); - end - xrf = 64'h41EFFC00000000FF; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h3FF00000FFDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4196689\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h40F77DF811CDE970; - zrf = 64'h3FE0E22091A23306; - ans = 64'hC0E77DE72FAD57CE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4197303\n"); - end - xrf = 64'h3FF4000000000006; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'hBC8000000000017F; - ans = 64'h3CB1FFFFFFFFFFD5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4197917\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h381FFFFBFFFFFFDF; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hB80FFFFBFFFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4198531\n"); - end - xrf = 64'h41FFF80000400000; - y = 64'h3FFFFFC000000400; - zrf = 64'hC010000100040000; - ans = 64'h420FF7C01020037D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4199145\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'hBFCFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4199759\n"); - end - xrf = 64'hC3EFFFFFEFFFFFFC; - y = 64'h7FD019CA601DDB9C; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4200373\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h41C6E41775375E0F; - ans = 64'h41C6E41775175E0F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4200987\n"); - end - xrf = 64'hC270000000403FFF; - y = 64'hC1EFFFFF5FFFFFFE; - zrf = 64'hB81FFFFFFFFFDFFF; - ans = 64'h446FFFFF60807FF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4201601\n"); - end - xrf = 64'h3FCD3CE853785FFB; - y = 64'h3FE0000000000001; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE3A79D0A6F0C00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4202215\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'hFFD000000020FFFE; - zrf = 64'hC16E07FFFFFFFFFF; - ans = 64'h7FC000000020FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4202829\n"); - end - xrf = 64'h3F000040FFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'hA1700003FFFFFFEE; - ans = 64'h3F000040FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4203443\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'hC004577471D38338; - zrf = 64'h8000000000000000; - ans = 64'h3FF4577471D38338; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4204057\n"); - end - xrf = 64'h3F3001F7FFFFFFFF; - y = 64'hAC2007F800000000; - zrf = 64'hC03FFFFFFC000040; - ans = 64'hC03FFFFFFC000040; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4204671\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h3FF0000000000001; - zrf = 64'h0010000000000000; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4205285\n"); - end - xrf = 64'h3EEFFFFF0007FFFF; - y = 64'hBC0845655D413167; - zrf = 64'hC010000000000001; - ans = 64'hC010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4205899\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h52BA92C061539D7C; - ans = 64'h52BA92C061539D7C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4206513\n"); - end - xrf = 64'hC08DA32C157C2D4D; - y = 64'hBFD000000001FFF6; - zrf = 64'h02AB4D7D90E4772F; - ans = 64'h406DA32C157FE1A0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4207127\n"); - end - xrf = 64'h37EFFFFFFFFEF7FE; - y = 64'h4000000000000000; - zrf = 64'h3FD0000000000001; - ans = 64'h3FD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4207741\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h3CAFFFFFFFFFF780; - zrf = 64'h3FF2F9E090618556; - ans = 64'h3FF2F9E090618556; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4208355\n"); - end - xrf = 64'h7FE63B8EC359EDE3; - y = 64'h4000000000000001; - zrf = 64'h4012020000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4208969\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h0AAFFF7FF7FFFFFF; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4209583\n"); - end - xrf = 64'h3FD00000000003FD; - y = 64'hC011800000000000; - zrf = 64'h43EF2303E8583374; - ans = 64'h43EF2303E8583374; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4210197\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h4010000000000000; - zrf = 64'h0000000000000001; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4210811\n"); - end - xrf = 64'hC011A149DA82F6AB; - y = 64'h480C5CACF91D9947; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC82F405F3F663848; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4211425\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h4010000000000001; - zrf = 64'h3FBCFFFFFFFFFFFF; - ans = 64'hBFFE300000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4212039\n"); - end - xrf = 64'hBCAAB55B719170B6; - y = 64'h41E53009E0FAAFB8; - zrf = 64'hC1C6435ADEF4CD2E; - ans = 64'hC1C6435ADEF4CD32; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4212653\n"); - end - xrf = 64'h3F780FFFFFFFFFFF; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3FA810000000001D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4213267\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'hF1AFEFFFFFC00000; - zrf = 64'hBFB080000FFFFFFE; - ans = 64'h719FEFFFFFC00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4213881\n"); - end - xrf = 64'hC010080000000800; - y = 64'h4340000000000000; - zrf = 64'h3FFFFBFFFC000000; - ans = 64'hC360080000000800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4214495\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h41DFFF7FFFFFFF7E; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4215109\n"); - end - xrf = 64'hC80EE00000000000; - y = 64'hBFF00000027FFFFF; - zrf = 64'hC1FC00000000FFFF; - ans = 64'h480EE00004D2FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4215723\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4216337\n"); - end - xrf = 64'hBA000000001FFFFC; - y = 64'hBFE00007FFEFFFFE; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hBFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4216951\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h7FE0000000000000; - zrf = 64'hC3DFFFFFFF6FFFFE; - ans = 64'hFFD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4217565\n"); - end - xrf = 64'hFFF07FFDFFFFFFFF; - y = 64'hB805929CC73FD5FD; - zrf = 64'h3FFFFFFFFFEFFFF0; - ans = 64'hFFF87FFDFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4218179\n"); - end - xrf = 64'h3FF907B1D6604523; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4218793\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'hC3E2782907133233; - zrf = 64'hC013FFFFFFFFFF7F; - ans = 64'h43D2782907133233; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4219407\n"); - end - xrf = 64'h43C0000001FEFFFF; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h38100000FFFFFFBF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4220021\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'hB65FFFFFFFE40000; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4220635\n"); - end - xrf = 64'hBFF00000FFFFBFFF; - y = 64'h40101F5900280A7C; - zrf = 64'hB8BFFFFFFE03FFFF; - ans = 64'hC0101F5A021D5A00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4221249\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h7FF0000000000001; - zrf = 64'hFFEFFFFFFFFFFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4221863\n"); - end - xrf = 64'h364000003FBFFFFE; - y = 64'hC34EFFFFF7FFFFFF; - zrf = 64'hBFF0000000000000; - ans = 64'hBFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4222477\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'hC0AFFFFFFFFFFFF7; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4223091\n"); - end - xrf = 64'hC00000400000001F; - y = 64'h3CA0000007FFFFDF; - zrf = 64'hB32001EFFFFFFFFE; - ans = 64'hBCB0004008001FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4223705\n"); - end - xrf = 64'h43F00002003FFFFE; - y = 64'h8000000000000001; - zrf = 64'h0010000000000000; - ans = 64'h80CFFE04007FFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4224319\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'hC0F00007FFFFDFFE; - zrf = 64'h43E00003FFFBFFFE; - ans = 64'h43E00003FFFC000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4224933\n"); - end - xrf = 64'hC3C405DA29D5572B; + x = 64'h425A6F792B92BECC; y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h3CAFFFFFFFFFFFDC; - ans = 64'h3CAFFFFFFFFFFFDC; + z = 64'h3FC000FFFFFFFF80; + ans = 64'h3FC000FFFFFFFF80; rn = 1; rz = 0; rm = 0; @@ -323465,19 +88745,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -323493,12 +88773,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4225547\n"); + $fwrite(fp,"3802431\n"); end - xrf = 64'hBFE0000000000000; - y = 64'h426B43762D2A2CB0; - zrf = 64'h4340000000000000; - ans = 64'h433FFF92F2274B57; + x = 64'hBFC0000000800008; + y = 64'h43D0001000000002; + z = 64'hC3CFFFFBFFFF8000; + ans = 64'hC3D20000000FC011; rn = 1; rz = 0; rm = 0; @@ -323512,19 +88792,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -323540,3630 +88820,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4226161\n"); + $fwrite(fp,"3804445\n"); end - xrf = 64'h3FFFFFFDEFFFFFFF; - y = 64'h002FFC0000080000; - zrf = 64'hBFEF6FFFFFFFFFFF; - ans = 64'hBFEF6FFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4226775\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h8010000000000000; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4227389\n"); - end - xrf = 64'h3DA928CA019BD3E0; - y = 64'h2ACFFFFFFDFFFFFF; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4228003\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h00000007FFF80000; - ans = 64'h00100007FFF80000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4228617\n"); - end - xrf = 64'h43CDFFFFFFFC0000; - y = 64'hA03033D9251BE4D2; - zrf = 64'h43EFFFFF00002000; - ans = 64'h43EFFFFF00002000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4229231\n"); - end - xrf = 64'h8010003FFFFFF7FF; - y = 64'hBCA0000000000000; - zrf = 64'h0000000000000001; - ans = 64'h0000000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4229845\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'hC01DFFFFFFFFFFF7; - zrf = 64'hFFDFFFFBFFDFFFFE; - ans = 64'hFFDFFFFBFFDFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4230459\n"); - end - xrf = 64'hC3DFF03FFFFFFFFE; - y = 64'hBCA0000000000001; - zrf = 64'h37EFFFFDFFFFF7FE; - ans = 64'h408FF04000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4231073\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h3FD45FD29D6D5857; - zrf = 64'h4010000000000001; - ans = 64'h400EBA02D6292A7D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4231687\n"); - end - xrf = 64'h400AB5DDE9B3278F; - y = 64'hC01FFC0000FFFFFF; - zrf = 64'hCC649C218C565351; - ans = 64'hCC649C218C565351; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4232301\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4232915\n"); - end - xrf = 64'hC80FFFFFFFFE000F; - y = 64'hB7E4A1AC18968B75; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'h4000A1AC18954164; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4233529\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'hBFD0000000000001; - zrf = 64'h7FDFF80FFFFFFFFF; - ans = 64'h7FDFF80FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4234143\n"); - end - xrf = 64'hB7E007FFFFC00000; - y = 64'hC7E02003FFFFFFFF; - zrf = 64'h3FC000002003FFFF; - ans = 64'h3FD8281411C17FEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4234757\n"); - end - xrf = 64'h3FE91717AF5FAB9A; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4235371\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h381F800000080000; - zrf = 64'hE37B068F54A1EB94; - ans = 64'hE37B068F54A1EB94; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4235985\n"); - end - xrf = 64'h2EA00080000001FF; - y = 64'hBFE0000000000000; - zrf = 64'h4CBFFFFFFFF001FF; - ans = 64'h4CBFFFFFFFF001FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4236599\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h41F00000000023FE; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'hC1DFFFFFFF0047FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4237213\n"); - end - xrf = 64'hC0376F95B96F7B7C; - y = 64'h480FF800000001FF; - zrf = 64'h400FFFFFE0040000; - ans = 64'hC85769B9D4012113; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4237827\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01DFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4238441\n"); - end - xrf = 64'hBFE00000007F0000; - y = 64'hBFCFF84000000000; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'h3FBFF84000FDC26C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4239055\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'hBFF0000000000000; - zrf = 64'hC17EFFFFFFFFFEFF; - ans = 64'hC17EFFFFF7FFFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4239669\n"); - end - xrf = 64'h3FD100000000FFFF; - y = 64'hC1FCF644B4425681; - zrf = 64'hC1D000000000FFDE; - ans = 64'hC1E762D47FC4A595; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4240283\n"); - end - xrf = 64'hD471BE317AD73197; - y = 64'hBFF0000000000001; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4240897\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h40000000000003F7; - zrf = 64'h400FFF8007FFFFFE; - ans = 64'h4007FF8007FFFE02; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4241511\n"); - end - xrf = 64'h38DFFFF808000000; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h3E007FFFFFFFFBFF; - ans = 64'h3E007FFFFFFFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4242125\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'hB80FFFFFFFFE8000; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h3FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4242739\n"); - end - xrf = 64'hC01FFEFFFFFFFFEF; - y = 64'h401A7ACD3B4C9466; - zrf = 64'hC3D000FFDFFFFFFF; - ans = 64'hC3D000FFDFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4243353\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'hC000000000000001; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC007FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4243967\n"); - end - xrf = 64'hC3DFFFDFFFFFDFFF; - y = 64'hC01FFFE003FFFFFE; - zrf = 64'hBCA0000000000000; - ans = 64'h440FFFC0041FDBFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4244581\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'hC7FFFFFFFFC003FF; - ans = 64'hC7FFFFFFFFC003FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4245195\n"); - end - xrf = 64'hC02B99A4F84CD304; - y = 64'h434FFFFFC01FFFFF; - zrf = 64'hBFEF691DBF97BAE2; - ans = 64'hC38B99A4C13522B8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4245809\n"); - end - xrf = 64'hC02FFFFFFFFDFEFE; - y = 64'hC010000000000000; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4246423\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h480F7FFFFFFFFFFE; - zrf = 64'h41C00000001FFEFF; - ans = 64'hC7FF7FFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4247037\n"); - end - xrf = 64'hC800500000000000; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h80107FFFFFEFFFFF; - ans = 64'h48304FFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4247651\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h3FEF00007FFFFFFE; - zrf = 64'h3FF0000000000000; - ans = 64'h3FE07FFFC0000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4248265\n"); - end - xrf = 64'h47F000000001FFF8; - y = 64'h53FF00000000001F; - zrf = 64'h43CFE0000FFFFFFE; - ans = 64'h5BFF00000003E010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4248879\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'hC340000000000000; - zrf = 64'hC000000000000000; - ans = 64'h432FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4249493\n"); - end - xrf = 64'hC2E64A9AEAE0880F; - y = 64'h402003FE00000000; - zrf = 64'h8010000000000001; - ans = 64'hC316502AC847E2D5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4250107\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hFFD037FFFFFFFFFF; - ans = 64'hFFD037FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4250721\n"); - end - xrf = 64'h3F2894DA01754BAD; - y = 64'h401699B30BB09BEA; - zrf = 64'hBFAFFFFFFFFFFFF2; - ans = 64'hBFAF751CC718509F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4251335\n"); - end - xrf = 64'hC0302003FFFFFFFF; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hC340000000000001; - ans = 64'h438F4007FFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4251949\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h43DFFFFFFF900000; - zrf = 64'h3F30000000000087; - ans = 64'hC3CFFFFFFF900000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4252563\n"); - end - xrf = 64'hC1CFFFBFF0000000; - y = 64'hFFE0000000000001; - zrf = 64'h7FEFFFFFF7FFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4253177\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h480AE209C671D38F; - zrf = 64'h3FE0000000000001; - ans = 64'hC7FAE209C671D38F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4253791\n"); - end - xrf = 64'h40300001FE000000; - y = 64'hDFF56A648CC95252; - zrf = 64'hC7F57319A5F461DE; - ans = 64'hE0356A673768975A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4254405\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'hBFF0000000000001; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4255019\n"); - end - xrf = 64'hBFB0030000000000; - y = 64'h554C0FFFFFFFFFFF; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'hD50C1542FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4255633\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'hFFF0000000000001; - zrf = 64'hBFF0000240000000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4256247\n"); - end - xrf = 64'h47EFFFFFFFFFEC00; - y = 64'hC4D000001FFFEFFE; - zrf = 64'h261F3FD0447206FB; - ans = 64'hCCD000001FFFE5FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4256861\n"); - end - xrf = 64'h90E0003FFFFFF800; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4257475\n"); - end - xrf = 64'hBFE0000000000000; - y = 64'h47F03FFFFFFFFBFF; - zrf = 64'h7FE0000000201FFF; - ans = 64'h7FE0000000201FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4258089\n"); - end - xrf = 64'hC037FFFFF7FFFFFF; - y = 64'h0000000000000000; - zrf = 64'h37FFFFFFF7FFEFFF; - ans = 64'h37FFFFFFF7FFEFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4258703\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'h403DA56F5B992731; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'hC02CA56F5B992733; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4259317\n"); - end - xrf = 64'hC3FFFFFE007FFFFE; - y = 64'hBFFFFFF000000400; - zrf = 64'hBFA0000001000000; - ans = 64'h440FFFEE008103BE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4259931\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4260545\n"); - end - xrf = 64'h3F4C008000000000; - y = 64'h3FFFC003FFFFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4261159\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'h0010000000000000; - zrf = 64'hBFF00010001FFFFF; - ans = 64'hBFF00010001FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4261773\n"); - end - xrf = 64'h486FFFFFFFFDF800; - y = 64'hC35A9189B6A07830; - zrf = 64'hB7FFFFFFFFFFFFFF; - ans = 64'hCBDA9189B69EC873; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4262387\n"); - end - xrf = 64'h380FFFFFFFFF8000; - y = 64'h0010000000000001; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4263001\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hCA70040004000000; - zrf = 64'h37E0000FFFFFFFBF; - ans = 64'h4A60040004000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4263615\n"); - end - xrf = 64'hBFCFFBFDFFFFFFFE; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hC7F00000040007FF; - ans = 64'hC7F00000040007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4264229\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'h230FD326A566D334; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h3CAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4264843\n"); - end - xrf = 64'h3FB70C705A4D06B3; - y = 64'h401AA11E416E7B40; - zrf = 64'h41CFFFDFFC000000; - ans = 64'h41CFFFDFFC4CB89F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4265457\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'h3CA0000000000001; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4266071\n"); - end - xrf = 64'h311FFFFBFFFFFFFD; - y = 64'hC7E28224D68FEEAC; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4266685\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h7FDFFFFF7FFFFF7F; - ans = 64'h7FDFFFFF7FFFFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4267299\n"); - end - xrf = 64'h9FB0000007FFFFFA; - y = 64'h397BFFFFFFFEFFFE; - zrf = 64'hBA6FFFDFFFFFFFF6; - ans = 64'hBA6FFFDFFFFFFFF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4267913\n"); - end - xrf = 64'h403000000007FBFF; - y = 64'h3FD0000000000000; - zrf = 64'hC000000000000000; - ans = 64'h40000000000FF7FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4268527\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hC000000000010000; - zrf = 64'hBD20007FFFFFF7FF; - ans = 64'h3FF000000000FF81; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4269141\n"); - end - xrf = 64'h3FA000000000FFF7; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h41D83BB13581CB53; - ans = 64'h41D83BB13582CB53; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4269755\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'h402FFFFFFFFFFFFE; - zrf = 64'h3CA0000000000000; - ans = 64'hC020000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4270369\n"); - end - xrf = 64'hDCDFFFFFFFFFBFFC; - y = 64'hC1601FFDFFFFFFFF; - zrf = 64'h403F989E481567E6; - ans = 64'h5E501FFDFFFFDFBD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4270983\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'h3FE0000000000000; - zrf = 64'hBFD0000000000000; - ans = 64'hBFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4271597\n"); - end - xrf = 64'h5BC0000000200003; - y = 64'h480BFFFFFFFFFFFD; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4272211\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h41D000000000FFFF; - ans = 64'h41CFFFFFFFC1FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4272825\n"); - end - xrf = 64'hBF4F800000001000; - y = 64'h1A900000000003FE; - zrf = 64'h43E0000000820000; - ans = 64'h43E0000000820000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4273439\n"); - end - xrf = 64'h2110010400000000; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'hBFF0000000000001; + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hBFF0000000000001; ans = 64'hBFF0000000000001; rn = 1; rz = 0; @@ -327178,19 +88839,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -327206,12 +88867,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4274053\n"); + $fwrite(fp,"3806459\n"); end - xrf = 64'hBFE0000000000001; - y = 64'hB7FFFFC003FFFFFE; - zrf = 64'h38100000000FFEFF; - ans = 64'h3813FFF8008FFEFF; + x = 64'hC9F0000FFFFFFFFC; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h4020020000000080; + ans = 64'h46B0000FFFFFFFFB; rn = 1; rz = 0; rm = 0; @@ -327225,19 +88886,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -327253,12 +88914,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4274667\n"); + $fwrite(fp,"3808473\n"); end - xrf = 64'hC20FF7FFFFFFFFBE; - y = 64'h3FF0000000000001; - zrf = 64'hC650037FFFFFFFFF; - ans = 64'hC650037FFFFFFFFF; + x = 64'h510FFFFFFFFFFFFF; + y = 64'hC06FFF80000001FF; + z = 64'hC1C8B1703B19FD4B; + ans = 64'hD18FFF80000001FE; rn = 1; rz = 0; rm = 0; @@ -327272,19 +88933,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -327300,12 +88961,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4275281\n"); + $fwrite(fp,"3810487\n"); end - xrf = 64'hBFE0000000000001; - y = 64'h3FF000807FFFFFFF; - zrf = 64'h0010000000000001; - ans = 64'hBFE0008080000000; + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; rn = 1; rz = 0; rm = 0; @@ -327319,19 +88980,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -327347,12 +89008,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4275895\n"); + $fwrite(fp,"3812501\n"); end - xrf = 64'hB7C0000007FFFFF6; - y = 64'h4803FFFFFF7FFFFF; - zrf = 64'h4000000000000041; - ans = 64'h3FFAFFFFFDA00085; + x = 64'h47FFFFFFFFC0FFFF; + y = 64'hBFE0000000000001; + z = 64'h40203FFFBFFFFFFE; + ans = 64'hC7EFFFFFFFC10001; rn = 1; rz = 0; rm = 0; @@ -327366,19 +89027,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -327394,12 +89055,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4276509\n"); + $fwrite(fp,"3814515\n"); end - xrf = 64'hBFE0000000000001; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hBCA0000000000001; - ans = 64'hBFF0000000000000; + x = 64'hC1F00080007FFFFE; + y = 64'h3FC000000000003B; + z = 64'h3FCFF80000000FFF; + ans = 64'hC1C0008000600839; rn = 1; rz = 0; rm = 0; @@ -327413,19 +89074,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -327441,716 +89102,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4277123\n"); + $fwrite(fp,"3816529\n"); end - xrf = 64'hFFF8A29BFF700631; - y = 64'h403106FEBFF88CA8; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'hFFF8A29BFF700631; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4277737\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'h4000000000000001; - zrf = 64'hD528287FE9510EA2; - ans = 64'hD528287FE9510EA2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4278351\n"); - end - xrf = 64'hBFE07FF7FFFFFFFF; - y = 64'hC02FFFFFFFFFFFFF; - zrf = 64'hFFDFFDFFFFFFFFF8; - ans = 64'hFFDFFDFFFFFFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4278965\n"); - end - xrf = 64'h41CFFF800000001F; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'h41EFFF7FFFE0001E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4279579\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'h002FFFFFF7FE0000; - zrf = 64'hC80FFFC000FFFFFE; - ans = 64'hC80FFFC000FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4280193\n"); - end - xrf = 64'hBFA9B95A03803E29; - y = 64'h4010000000000000; - zrf = 64'h40AFFEFFFFFFFBFF; - ans = 64'h40AFFE991A97EDFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4280807\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'h48BFFFFFC8000000; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hC8AFFFFFC8000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4281421\n"); - end - xrf = 64'hBB400007FFFFC000; - y = 64'h403DA52BE207AB6E; - zrf = 64'hC02FFFFFF801FFFF; - ans = 64'hC02FFFFFF801FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4282035\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4282649\n"); - end - xrf = 64'hBFC4E2D7BB50CF8D; - y = 64'hC06FFDFFF7FFFFFF; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h4048E189889C6490; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4283263\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'h4340000000000000; - zrf = 64'hB51000107FFFFFFF; - ans = 64'hC330000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4283877\n"); - end - xrf = 64'hC03000041FFFFFFF; - y = 64'h4023FFFF7FFFFFFF; - zrf = 64'h400D4AF9C524EA86; - ans = 64'hC0638AD8C0EB4B54; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4284491\n"); - end - xrf = 64'h40200FFFFC000000; - y = 64'h4340000000000001; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'h43700FFFFC000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4285105\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hC04FFFFFFFFFFC7F; - zrf = 64'hB640003FFFFFFFFD; - ans = 64'h403FFFFFFFFFFC81; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4285719\n"); - end - xrf = 64'h4015DEEB496D12F9; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hC1DCED85EE041FB4; - ans = 64'h4375DEEB4231B17C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4286333\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'h5C8FFFFFDFFFFFFE; - zrf = 64'hFFFFFFFFFFFFFFFE; + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -328165,19 +89121,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -328193,12 +89149,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4286947\n"); + $fwrite(fp,"3818543\n"); end - xrf = 64'hBFFC9F5D83E1AE22; - y = 64'hB8000000101FFFFF; - zrf = 64'hC10FFFFE7FFFFFFF; - ans = 64'hC10FFFFE7FFFFFFF; + x = 64'h3FE0000200010000; + y = 64'hC000000000000001; + z = 64'h43F000003FFFFFC0; + ans = 64'h43F000003FFFFFC0; rn = 1; rz = 0; rm = 0; @@ -328212,19 +89168,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -328240,12 +89196,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4287561\n"); + $fwrite(fp,"3820557\n"); end - xrf = 64'hBFE0000000000001; - y = 64'h7FE0000000000001; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hFFD0000000000002; + x = 64'hC02000000000077E; + y = 64'hC7C2000000080000; + z = 64'hC03FFFFFC0000000; + ans = 64'h47F200000008086E; rn = 1; rz = 0; rm = 0; @@ -328259,19 +89215,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -328287,12 +89243,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4288175\n"); + $fwrite(fp,"3822571\n"); end - xrf = 64'h3FD2FB12CD179D16; - y = 64'h1A10000001FFFFDF; - zrf = 64'h4010000000000000; - ans = 64'h4010000000000000; + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h3CDBFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -328306,19 +89262,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -328334,12 +89290,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4288789\n"); + $fwrite(fp,"3824585\n"); end - xrf = 64'hBFE0000000000001; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hBA90E4441609C811; - ans = 64'hFFE0000000000000; + x = 64'h7FF0000000001001; + y = 64'hC340000000000001; + z = 64'hBFDFFFFFBF7FFFFF; + ans = 64'h7FF8000000001001; rn = 1; rz = 0; rm = 0; @@ -328353,19 +89309,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -328381,12 +89337,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4289403\n"); + $fwrite(fp,"3826599\n"); end - xrf = 64'h4001FEFFFFFFFFFE; - y = 64'hCAAFF77FFFFFFFFF; - zrf = 64'hC1CFFFFFFFFFBDFF; - ans = 64'hCAC1FA3843FFFFFD; + x = 64'hBFDEED3A52F92CAE; + y = 64'hB7EF2623838B25E1; + z = 64'h7FDEFFBFFFFFFFFE; + ans = 64'h7FDEFFBFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -328400,19 +89356,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -328428,11 +89384,58 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4290017\n"); + $fwrite(fp,"3828613\n"); end - xrf = 64'hC032D1136CBBCF89; - y = 64'h7FF0000000000000; - zrf = 64'hBFD0000000000000; + x = 64'hBCAFFFFFFFFFFFFF; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'h7CAFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3830627\n"); + end + x = 64'h3FF801FFFFFFFFFF; + y = 64'hFFF0000000000000; + z = 64'h4060010000000008; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -328447,19 +89450,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -328475,12 +89478,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4290631\n"); + $fwrite(fp,"3832641\n"); end - xrf = 64'hBFE0000000000001; - y = 64'h402FF80000000010; - zrf = 64'h3B50AC8A45A9076E; - ans = 64'hC01FF80000000012; + x = 64'hBFFFFFFFFFFFBF7E; + y = 64'hC07F05AF578DC2B5; + z = 64'hB7E4F687E4E02EF6; + ans = 64'h408F05AF578D842C; rn = 1; rz = 0; rm = 0; @@ -328494,19 +89497,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -328522,11 +89525,763 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4291245\n"); + $fwrite(fp,"3834655\n"); end - xrf = 64'hC078DBF65DDA9B22; + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h0000000000000001; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3836669\n"); + end + x = 64'h3FA0000007FFFF80; + y = 64'h0010000000000000; + z = 64'h40D00004000007FF; + ans = 64'h40D00004000007FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3838683\n"); + end + x = 64'h19CA7373ABD10AFC; + y = 64'h3D4010007FFFFFFE; + z = 64'hBFD0000004000000; + ans = 64'hBFD0000004000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3840697\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h3CA0000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3842711\n"); + end + x = 64'hC3DFFFFFF000000F; + y = 64'h3FD0000000000000; + z = 64'h400000FFFEFFFFFF; + ans = 64'hC3BFFFFFF000000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3844725\n"); + end + x = 64'h402FFFDFFBFFFFFE; + y = 64'hC4A00000003FFFFF; + z = 64'h3E4EDA17C4C51030; + ans = 64'hC4DFFFDFFC7FFF7C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3846739\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h3FE0000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3C9FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3848753\n"); + end + x = 64'h400A345EEB63AB2B; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h3FC00001FFFFBFFF; + ans = 64'h400B345F0B63A729; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3850767\n"); + end + x = 64'hBFFA3A6CEF49B307; + y = 64'hC9603FFDFFFFFFFE; + z = 64'hC47FFFFF803FFFFF; + ans = 64'h496AA3535BB93BE7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3852781\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h4000000000000000; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3854795\n"); + end + x = 64'h7FDFFFFFFF800004; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hCB200000200FFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3856809\n"); + end + x = 64'hBFCBBA3F322084BE; + y = 64'hB7F48A14E108CB87; + z = 64'hFFDFFFFFFF000001; + ans = 64'hFFDFFFFFFF000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3858823\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h4340000000000000; + z = 64'h4340000000000000; + ans = 64'h433FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3860837\n"); + end + x = 64'h3FA0000003FFFF7E; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hC3D7FFFFFFFFFFFC; + ans = 64'hC3D7FF7FFFFFDFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3862851\n"); + end + x = 64'h3FEF869027739B45; + y = 64'h41C1000400000000; + z = 64'hBFDFFFFF6FFFFFFF; + ans = 64'h41C0BF8085876F6C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3864865\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3866879\n"); + end + x = 64'h47FFF7DFFFFFFFFF; y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h4000200000002000; + z = 64'hBFE00001FFFFFFFD; ans = 64'h7FFFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -328541,19 +90296,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -328569,11 +90324,669 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4291859\n"); + $fwrite(fp,"3868893\n"); end - xrf = 64'hBFE0000000000001; - y = 64'hBF6FFFFFFFFFE7FF; - zrf = 64'hFFF0000000000000; + x = 64'h7FF750D3ECFE8591; + y = 64'h30CFFBFFFFEFFFFF; + z = 64'hBE3FFFFFEFFFFFFD; + ans = 64'h7FFF50D3ECFE8591; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3870907\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3872921\n"); + end + x = 64'hC2703FE000000000; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hC3C0001800000000; + ans = 64'hC3C0001800000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3874935\n"); + end + x = 64'h7061412003346D04; + y = 64'hC1F01FFFFFFFFFFF; + z = 64'h322FFFFF80000001; + ans = 64'hF26163A2433AD5DD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3876949\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3878963\n"); + end + x = 64'hC033FFFFFFFFFFFD; + y = 64'hBFD0000000000001; + z = 64'hD590000300000000; + ans = 64'hD590000300000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3880977\n"); + end + x = 64'h402FC00000000001; + y = 64'hC92FFFFFFFFFFFFE; + z = 64'h400997A6065DBA19; + ans = 64'hC96FBFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3882991\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3885005\n"); + end + x = 64'hC8000000000007F8; + y = 64'hBFF0000000000001; + z = 64'h24E00000007FFFFE; + ans = 64'h48000000000007F9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3887019\n"); + end + x = 64'h3F50000001002000; + y = 64'h55C8A74A57511C8B; + z = 64'h7537B3CA2789A11F; + ans = 64'h7537B3CA2789A11F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3889033\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3891047\n"); + end + x = 64'h41F0010040000000; + y = 64'hC010000000000001; + z = 64'hAAE00001FFFFFFFA; + ans = 64'hC210010040000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3893061\n"); + end + x = 64'h4257359EB830CE5B; + y = 64'hBFD000400FFFFFFF; + z = 64'h7350000004400000; + ans = 64'h7350000004400000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3895075\n"); + end + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h400FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3897089\n"); + end + x = 64'h434000000000005F; + y = 64'hFFE0000000000000; + z = 64'hC3EFFDFF00000000; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -328588,19 +91001,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -328616,12 +91029,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4292473\n"); + $fwrite(fp,"3899103\n"); end - xrf = 64'h2E40020001FFFFFF; - y = 64'hBE2FF00008000000; - zrf = 64'h404FC00001FFFFFE; - ans = 64'h404FC00001FFFFFE; + x = 64'hC02FC0000000000F; + y = 64'hBCA398F05424163D; + z = 64'hC1E0000004800000; + ans = 64'hC1E0000004800000; rn = 1; rz = 0; rm = 0; @@ -328635,19 +91048,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -328663,12 +91076,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4293087\n"); + $fwrite(fp,"3901117\n"); end - xrf = 64'hBFE0000000000001; - y = 64'h8000000000000000; - zrf = 64'h8000000000000000; - ans = 64'h0000000000000000; + x = 64'hBCAFFFFFFFFFFFFE; + y = 64'hFFF0000000000001; + z = 64'hBFF0000000000001; + ans = 64'hFFF8000000000001; rn = 1; rz = 0; rm = 0; @@ -328682,19 +91095,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -328710,12 +91123,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4293701\n"); + $fwrite(fp,"3903131\n"); end - xrf = 64'h41DFFF6FFFFFFFFF; - y = 64'h392F7FFFFEFFFFFF; - zrf = 64'h4000000000000001; - ans = 64'h4000000000000001; + x = 64'hC95FDFFFFFFFFDFF; + y = 64'h0000000000000000; + z = 64'hBAAFFF7FFFFFFFDF; + ans = 64'hBAAFFF7FFFFFFFDF; rn = 1; rz = 0; rm = 0; @@ -328729,19 +91142,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -328757,12 +91170,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4294315\n"); + $fwrite(fp,"3905145\n"); end - xrf = 64'hBFE0000000000001; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hC05FFFFFFF7DFFFF; - ans = 64'hC05FFFFFFF7DFFFF; + x = 64'hE4C25C774D9F6F1B; + y = 64'h401FC00000FFFFFF; + z = 64'h3C3000000007EFFF; + ans = 64'hE4F237BE5F9713F7; rn = 1; rz = 0; rm = 0; @@ -328776,19 +91189,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -328804,12 +91217,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4294929\n"); + $fwrite(fp,"3907159\n"); end - xrf = 64'h9DF000100FFFFFFF; - y = 64'h3C100000080007FE; - zrf = 64'h800D4CE01FAF4EB1; - ans = 64'h9A10001018001005; + x = 64'hBFD0000000000000; + y = 64'h0010000000000001; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; rn = 1; rz = 0; rm = 0; @@ -328823,19 +91236,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -328851,12 +91264,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4295543\n"); + $fwrite(fp,"3909173\n"); end - xrf = 64'h41CFFFFF7FFFFFFD; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; + x = 64'hA35FFFFE000FFFFF; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h7FD00001FFEFFFFF; + ans = 64'h7FD00001FFEFFFFF; rn = 1; rz = 0; rm = 0; @@ -328870,19 +91283,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -328898,12 +91311,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4296157\n"); + $fwrite(fp,"3911187\n"); end - xrf = 64'hBFE0000000000001; - y = 64'hC0EFFFFFFFFFE000; - zrf = 64'h3F57FFFFFFF7FFFF; - ans = 64'h40E000000BFFF001; + x = 64'h7FEC000000003FFF; + y = 64'hBB8FFFFFFF807FFE; + z = 64'h00060171223E7BB8; + ans = 64'hFB8BFFFFFF90AFFD; rn = 1; rz = 0; rm = 0; @@ -328917,19 +91330,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -328945,2361 +91358,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4296771\n"); + $fwrite(fp,"3913201\n"); end - xrf = 64'hB81FFFFFFF7FBFFF; - y = 64'h8010000000000001; - zrf = 64'h3FC2000000000001; - ans = 64'h3FC2000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4297385\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hBCA000000803FFFF; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4297999\n"); - end - xrf = 64'hC1FFFFFFF6FFFFFF; - y = 64'hBEB0020000001FFE; - zrf = 64'h40E000000100003F; - ans = 64'h40E4007FFFDFE43E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4298613\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4299227\n"); - end - xrf = 64'hBFFBFFF7FFFFFFFF; - y = 64'hC3D3FFFFFFFFFFDF; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h43E17FFAFFFFFFE3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4299841\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hBCA0000000000001; - zrf = 64'hC0F9E562B951C9DC; - ans = 64'hC0F9E562B951C9DC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4300455\n"); - end - xrf = 64'hE2BEFFFFF7FFFFFE; - y = 64'hC012F0C4E57CAAF2; - zrf = 64'h406C11981FF70932; - ans = 64'h62E2593EB9949460; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4301069\n"); - end - xrf = 64'hBEF0000000000BFF; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h3BB0000000000BFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4301683\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hB81D237B243DCBC4; - zrf = 64'h8010000013FFFFFF; - ans = 64'h380D237B243DCBC6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4302297\n"); - end - xrf = 64'h37F000000000FFF7; - y = 64'hBFD0000000000000; - zrf = 64'h7FF000100000001E; - ans = 64'h7FF800100000001E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4302911\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hBA3B957DEF8DB79B; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4303525\n"); - end - xrf = 64'hC79C000000000800; - y = 64'hFFD0010000400000; - zrf = 64'hBFC00000000080FF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4304139\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4304753\n"); - end - xrf = 64'hC344001FFFFFFFFE; - y = 64'h381F7FFFFFFF0000; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h3FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4305367\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h419FFFFFFEFFFFF6; - ans = 64'h419FFFFFFFFFFFF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4305981\n"); - end - xrf = 64'hBFCFFFFFDFFFFF7F; - y = 64'hBFF000020000FFFF; - zrf = 64'hBF9BA0C1C5FC70F4; - ans = 64'h3FCC8BEBA7426D5E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4306595\n"); - end - xrf = 64'h443FFFFFFFFFEFFF; - y = 64'hBFE0000000000001; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hC42FFFFFFFFFF001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4307209\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hC7E0040000020000; - zrf = 64'h43529CE838478CE0; - ans = 64'h47D0040000020001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4307823\n"); - end - xrf = 64'h43D4C6A2B748F3D4; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h801FFFEDFFFFFFFF; - ans = 64'hC3D4C6A2B748F3D3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4308437\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'h38000000001FFBFF; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4309051\n"); - end - xrf = 64'h3C8000008001FFFE; - y = 64'h7FE8AF46D1B57450; - zrf = 64'h305325F5B2DB62A5; - ans = 64'h7C78AF479732C0C3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4309665\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hBFF0000000000001; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4310279\n"); - end - xrf = 64'hFFF000007DFFFFFF; - y = 64'h43FFFFFFFFFFFDFB; - zrf = 64'h3FE0000000000000; - ans = 64'hFFF800007DFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4310893\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'hC50007FFFFFFFFFB; - ans = 64'hC50007FFFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4311507\n"); - end - xrf = 64'hC35EFAD13412EBFC; - y = 64'h41FFFFFFFFFFC003; - zrf = 64'hC0500000007FFFFD; - ans = 64'hC56EFAD13412AE09; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4312121\n"); - end - xrf = 64'hC80FFFBFFFBFFFFE; - y = 64'hC000000000000000; - zrf = 64'h8000000000000000; - ans = 64'h481FFFBFFFBFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4312735\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hC3D0FFFFFFFFFFF7; - zrf = 64'h3F8416248D18D08E; - ans = 64'h43C0FFFFFFFFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4313349\n"); - end - xrf = 64'hA0B6BB4161A3018F; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h41DFFFEFDFFFFFFF; - ans = 64'h41DFFFEFDFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4313963\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'h381000100003FFFE; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4314577\n"); - end - xrf = 64'hB7E8C10112B5A9DB; - y = 64'h401E5426B7B1D83E; - zrf = 64'h3FD3561714AC1ABF; - ans = 64'h3FD3561714AC1ABF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4315191\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hC010000000000000; - zrf = 64'h4340000000000000; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4315805\n"); - end - xrf = 64'h3CAFFFFFBFFFFBFF; - y = 64'h3FE8644FB2E006BE; - zrf = 64'h3FD0000000000001; - ans = 64'h3FD0000000000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4316419\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hC010000000000001; - zrf = 64'h381000000003FDFF; - ans = 64'h4000000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4317033\n"); - end - xrf = 64'hC1C100000000000F; - y = 64'hC00FFFFFFFE7FFFE; - zrf = 64'h40252B03F5F1276A; - ans = 64'h41E100000145F04D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4317647\n"); - end - xrf = 64'h4017E1F8BDA99D9B; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4318261\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hBD7FFF5FFFFFFFFF; - zrf = 64'hFFEFFFFFFFFFFEFF; - ans = 64'hFFEFFFFFFFFFFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4318875\n"); - end - xrf = 64'hBFBFFEFFFFFFFC00; - y = 64'hC340000000000001; - zrf = 64'hC19FFFFFFF801FFE; - ans = 64'h430FFEFFBFFFFC03; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4319489\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'h3D00007F7FFFFFFF; - zrf = 64'hC000000000000001; - ans = 64'hC000000000000009; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4320103\n"); - end - xrf = 64'h80207FFFFFFFFFFF; - y = 64'h4000077FFFFFFFFF; - zrf = 64'h3EDFFFFFFFFFE040; - ans = 64'h3EDFFFFFFFFFE040; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4320717\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h4010000000000001; - ans = 64'h4340000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4321331\n"); - end - xrf = 64'h3D90200000800000; - y = 64'h3FC4F21FA9505D0B; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3D651E03E94A8EC2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4321945\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hFFE0000000000000; - zrf = 64'h37EFFFFE0003FFFE; - ans = 64'h7FD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4322559\n"); - end - xrf = 64'h3FBF7FFFFFFFFFFF; - y = 64'hC06FFFC200000000; - zrf = 64'h4030000000201FFE; - ans = 64'hC02EFF85EFBFC002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4323173\n"); - end - xrf = 64'hC3C000000023FFFF; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4323787\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hBCA0011FFFFFFFFE; - zrf = 64'h403659433C03BF12; - ans = 64'h403659433C03BF12; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4324401\n"); - end - xrf = 64'h3EB0BDBC939F5849; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h4250000000008001; - ans = 64'hFEB0BDBC939F5848; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4325015\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hBE1000000007BFFF; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4325629\n"); - end - xrf = 64'h4340000004000006; - y = 64'h4010576939197802; - zrf = 64'hBFC00007FC000000; - ans = 64'h436057693D2F5256; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4326243\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h400FFFFFFFFFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4326857\n"); - end - xrf = 64'hB7EB19E2887D97FC; - y = 64'h43E0000000080FFF; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'hBBDB19E2888B4005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4327471\n"); - end - xrf = 64'hBFE0000000000001; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'hB15B74BD2A9679FB; + x = 64'hBFD0000000000000; + y = 64'h3FD0000000000000; + z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -331314,19 +91377,9654 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3915215\n"); + end + x = 64'h43D0000100000001; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hBD9FFFFFEFFFEFFF; + ans = 64'h43C0000100000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3917229\n"); + end + x = 64'hBDF0000000020002; + y = 64'h409FFFFFEFFF7FFF; + z = 64'hC020000000008000; + ans = 64'hC020000010007FF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3919243\n"); + end + x = 64'hBFD0000000000000; + y = 64'h3FF0000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBFD0000000000004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3921257\n"); + end + x = 64'hBFB0000000080080; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hFFD00200FFFFFFFF; + ans = 64'hFFD00200FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3923271\n"); + end + x = 64'hBFFFFFFFF0000004; + y = 64'h43F000000FF00000; + z = 64'hBFCFFFFFFEFFFF00; + ans = 64'hC400000007EFFFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3925285\n"); + end + x = 64'hBFD0000000000000; + y = 64'h4010000000000000; + z = 64'h3FF0000000000001; + ans = 64'h3CB0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3927299\n"); + end + x = 64'hC1EFFFFE0000007E; + y = 64'h401FFFFFFFFFFFFF; + z = 64'hC3C73160DA37C1BE; + ans = 64'hC3C73160DE37C17E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3929313\n"); + end + x = 64'h7FD00000000002FE; + y = 64'h301FFFFFFFFFE3FE; + z = 64'h30E800003FFFFFFE; + ans = 64'h6FFFFFFFFFFFE9FA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3931327\n"); + end + x = 64'hBFD0000000000000; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'hC348000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3933341\n"); + end + x = 64'h41D00000000107FE; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h48201DFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3935355\n"); + end + x = 64'h801FFFFFFFFFDBFF; + y = 64'hC1FEFFFFFFFFF7FF; + z = 64'h47E3FFDFFFFFFFFF; + ans = 64'h47E3FFDFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3937369\n"); + end + x = 64'hBFD0000000000000; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3939383\n"); + end + x = 64'hC62020000000007F; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hBFDFFFFFFFFFFFFF; + ans = 64'hBFDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3941397\n"); + end + x = 64'hB80FFFFFF7BFFFFF; + y = 64'hC7FFFFFF10000000; + z = 64'h43BFFFFBFFFFBFFF; + ans = 64'h43BFFFFBFFFFBFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3943411\n"); + end + x = 64'hBFD0000000000000; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3945425\n"); + end + x = 64'h7FF00000000043FF; + y = 64'hBCA0000000000001; + z = 64'hC5D6CCE3D680D70E; + ans = 64'h7FF80000000043FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3947439\n"); + end + x = 64'hC01FF7FFFFFFFFFE; + y = 64'h43D0001FFFFFF000; + z = 64'h7FDFFFFFFBFFFEFF; + ans = 64'h7FDFFFFFFBFFFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3949453\n"); + end + x = 64'hBFD0000000000000; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hBFEC000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3951467\n"); + end + x = 64'hBCCB12E85BCA0CFE; + y = 64'hBFE0000000000001; + z = 64'h3F0FFFFF7FFFEFFF; + ans = 64'h3F0FFFFF8000C896; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3953481\n"); + end + x = 64'h802080000000FFFF; + y = 64'h5730000000000040; + z = 64'h7FF0000FFDFFFFFE; + ans = 64'h7FF8000FFDFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3955495\n"); + end + x = 64'hBFD0000000000000; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3957509\n"); + end + x = 64'h41900007FFFFFFFE; + y = 64'hC000000000000000; + z = 64'h41CE00007FFFFFFF; + ans = 64'h41C9FFFE80000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3959523\n"); + end + x = 64'hFFE020000001FFFF; + y = 64'hBFA6A9294AD2EAA6; + z = 64'h40200000000007E0; + ans = 64'h7F96D67B9D6B659F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3961537\n"); + end + x = 64'hBFD0000000000000; + y = 64'hC010000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3963551\n"); + end + x = 64'hC7E656DF82463376; + y = 64'hC340000000000000; + z = 64'hFFDF000800000000; + ans = 64'hFFDF000800000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3965565\n"); + end + x = 64'h7ACDFFFFFFFFF800; + y = 64'h401FFFFFFE000800; + z = 64'h41ED906DDCD6B5DD; + ans = 64'h7AFDFFFFFE1FFF80; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3967579\n"); + end + x = 64'hBFD0000000000000; + y = 64'hFFE0000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h7FC0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3969593\n"); + end + x = 64'hC1D00000200001FF; + y = 64'hFFF0000000000000; + z = 64'hC01B8CDE8DE11ABC; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3971607\n"); + end + x = 64'h3FEFFFFFFFF80040; + y = 64'h43D00000017FFFFF; + z = 64'h40803FE000000000; + ans = 64'h43D00000017C0020; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3973621\n"); + end + x = 64'hBFD0000000000001; + y = 64'h0000000000000001; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3975635\n"); + end + x = 64'h3D9FDFFFFFFFFE00; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hC0271DEF2549D40C; + ans = 64'hC0271DEF2549D40C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3977649\n"); + end + x = 64'hA480000FEFFFFFFF; + y = 64'hBFDF7FFBFFFFFFFF; + z = 64'h3FEBFFFF7FFFFFFE; + ans = 64'h3FEBFFFF7FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3979663\n"); + end + x = 64'hBFD0000000000001; + y = 64'h3CA0000000000000; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3981677\n"); + end + x = 64'h380FEFFFFFFF8000; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'hB7FF00000003FFFF; + ans = 64'hB7FF00000003FFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3983691\n"); + end + x = 64'hBFEF000FFFFFFFFF; + y = 64'h43ED53D0520EAC50; + z = 64'hC1F9B9E740692E8A; + ans = 64'hC3EC69407999D3C2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3985705\n"); + end + x = 64'hBFD0000000000001; + y = 64'h3FE0000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3987719\n"); + end + x = 64'h3FFA65BB6D3D049F; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h0000003FFFFBFFFF; + ans = 64'h3FFA65BB6D3D049D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3989733\n"); + end + x = 64'hA07000000003FFC0; + y = 64'hBFCFFFFFE0010000; + z = 64'h37F04000000000FE; + ans = 64'h37F04000000000FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3991747\n"); + end + x = 64'hBFD0000000000001; + y = 64'h4000000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hBFDFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3993761\n"); + end + x = 64'h0020000000220000; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h41A03FFBFFFFFFFF; + ans = 64'h41A03FFBFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3995775\n"); + end + x = 64'hBFC2576242253287; + y = 64'hB7F7DE6C30DD0BEF; + z = 64'hFFFFFFFFFFFF801F; + ans = 64'hFFFFFFFFFFFF801F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3997789\n"); + end + x = 64'hBFD0000000000001; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hC008000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"3999803\n"); + end + x = 64'h297DFFE000000000; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hB9AFD73D50E72C73; + ans = 64'hB9AFD73D50E72C73; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4001817\n"); + end + x = 64'hC3C520C29AB52637; + y = 64'h4809CCE33765D79E; + z = 64'h4342000000000010; + ans = 64'hCBE108DEE66FCE60; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4003831\n"); + end + x = 64'hBFD0000000000001; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'hFFD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4005845\n"); + end + x = 64'hBFBFFBFFFFFFFFEF; + y = 64'h7FF0000000000001; + z = 64'hFFDF7FFFFFFFFF7F; + 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,"4007859\n"); + end + x = 64'h48017FFFFFFFFFFE; + y = 64'hC03D388E8E5584AC; + z = 64'h3FE0000000000010; + ans = 64'hC84FF5DBEBAD8918; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4009873\n"); + end + x = 64'hBFD0000000000001; + y = 64'h800FFFFFFFFFFFFF; + 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,"4011887\n"); + end + x = 64'h37FFE468EB15AC0A; + y = 64'h8010000000000001; + z = 64'hBF7FFFFFEFFFFFEE; + ans = 64'hBF7FFFFFEFFFFFEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4013901\n"); + end + x = 64'h402C000000000400; + y = 64'hCBB0000000000000; + z = 64'h7FDFFFFFFFFF7FEE; + ans = 64'h7FDFFFFFFFFF7FEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4015915\n"); + end + x = 64'hBFD0000000000001; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCA7FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4017929\n"); + end + x = 64'hDC4FFFFFFFFF001F; + y = 64'hBFD0000000000001; + z = 64'h54CFFFFFFFF7F7FE; + ans = 64'h5C2FFFFFFFFF0021; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4019943\n"); + end + x = 64'hB81FFFE00000001E; + y = 64'hC010000BFFFFFFFE; + z = 64'hC053557D26B59CB1; + ans = 64'hC053557D26B59CB1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4021957\n"); + end + x = 64'hBFD0000000000001; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'h3FF4000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4023971\n"); + end + x = 64'h480000001FFFFEFF; + y = 64'hBFF0000000000000; + z = 64'h40D86887350870A0; + ans = 64'hC80000001FFFFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4025985\n"); + end + x = 64'hFFF000407FFFFFFE; + y = 64'hC1DFFFFFFCFFFFFF; + z = 64'hC3E55EBCA5EEB15B; + ans = 64'hFFF800407FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4027999\n"); + end + x = 64'hBFD0000000000001; + y = 64'hC000000000000001; + z = 64'hC340000000000000; + ans = 64'hC33FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4030013\n"); + end + x = 64'hC020100000000020; + y = 64'hC010000000000000; + z = 64'h48040000000000FF; + ans = 64'h48040000000000FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4032027\n"); + end + x = 64'hBF5FFFFFFFE000FE; + y = 64'h335D310274E925EE; + z = 64'hBAC000000000000B; + ans = 64'hBAC000000000000B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4034041\n"); + end + x = 64'hBFD0000000000001; + y = 64'hC340000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4036055\n"); + end + x = 64'h380BFFFFFFFBFFFF; + y = 64'hFFE0000000000000; + z = 64'hC01555741BD41CAB; + ans = 64'hF7FBFFFFFFFBFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4038069\n"); + end + x = 64'h3CD9B40821F9B3E4; + y = 64'h201F7FFEFFFFFFFF; + z = 64'h403FFFFFFC003FFE; + ans = 64'h403FFFFFFC003FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4040083\n"); + end + x = 64'hBFD0000000000001; + y = 64'hFFF0000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4042097\n"); + end + x = 64'hC03FFFFFC00001FF; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hBFDF000000000007; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4044111\n"); + end + x = 64'h410FFBFFBFFFFFFE; + y = 64'hB734156DEC8DD607; + z = 64'h43D009FFFFFFFFFF; + ans = 64'h43D009FFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4046125\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h0010000000000000; + z = 64'hBFF0000000000001; + 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,"4048139\n"); + end + x = 64'hC7FFFFFBFFC00000; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hC7E0000000600000; + ans = 64'hC7E0000000600000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4050153\n"); + end + x = 64'hC56FFFFFFEFF8000; + y = 64'hC34E2F7D229264D7; + z = 64'hD7EBFFFFFFFFEFFE; + ans = 64'hD7EBFFFFFFFFEFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4052167\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h3FD0000000000000; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4054181\n"); + end + x = 64'hC1C2485C59A21EE6; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h43E0008000001000; + ans = 64'h43E0007FFFFDC6F4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4056195\n"); + end + x = 64'h40117FFFFFFFFFFF; + y = 64'hC01CA9044303E0DB; + z = 64'h4C2000801FFFFFFF; + ans = 64'h4C2000801FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4058209\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h3FEFFFFFFFFFFFFE; + 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,"4060223\n"); + end + x = 64'hCDFFFFFFFFFD8000; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h47E128374FD5C32C; + ans = 64'hCE0FFFFFFFFD7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4062237\n"); + end + x = 64'hC3D0001000000100; + y = 64'hB8100000207FFFFF; + z = 64'h400000000001003F; + ans = 64'h400000000001003F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4064251\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4066265\n"); + end + x = 64'hBCA007FFFFFFF7FE; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h4050000000000FFD; + ans = 64'h4050000000000FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4068279\n"); + end + x = 64'hBFB000000001FFFB; + y = 64'hC13E89BE71AC5F37; + z = 64'h43E0000000000203; + ans = 64'h43E0000000000240; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4070293\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'hC33FFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4072307\n"); + end + x = 64'hBCA2000000080000; + y = 64'h7FE0000000000001; + z = 64'h3FE0000080000003; + ans = 64'hFC92000000080001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4074321\n"); + end + x = 64'h3F9FFFFDFFFFFFBF; + y = 64'h43EFFC0000000000; + z = 64'h3EC6AF993615E8BC; + ans = 64'h439FFBFE003FFFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4076335\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4078349\n"); + end + x = 64'hC0A0001EFFFFFFFE; + y = 64'h8000000000000001; + z = 64'hC1C008000007FFFF; + ans = 64'hC1C008000007FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4080363\n"); + end + x = 64'h3CC56618EC6D04EC; + y = 64'hC02FFFFFFFF00000; + z = 64'h404003FFFFE00000; + ans = 64'h404003FFFFDFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4082377\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4084391\n"); + end + x = 64'h4340000007BFFFFF; + y = 64'hBCA0000000000001; + z = 64'hFFDA1FF2E2AAA6DA; + ans = 64'hFFDA1FF2E2AAA6DA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4086405\n"); + end + x = 64'h41DFFF0003FFFFFF; + y = 64'hC8600007FFFFFFFD; + z = 64'hBFDF001FFFFFFFFF; + ans = 64'hCA4FFF10038001F9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4088419\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3FD0000000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4090433\n"); + end + x = 64'h3F3E007FFFFFFFFE; + y = 64'hBFE0000000000000; + z = 64'h3FF0000000001F7F; + ans = 64'h3FEFFE1FF8003EFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4092447\n"); + end + x = 64'h22E0000000003FBE; + y = 64'hBFF9249E6C798660; + z = 64'h3C8FFFFCFFFFFFFF; + ans = 64'h3C8FFFFCFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4094461\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'hBFF0000000000001; + z = 64'hBFF0000000000001; + ans = 64'hBFE0000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4096475\n"); + end + x = 64'hC0BEFFDFFFFFFFFF; + y = 64'hC000000000000000; + z = 64'hBFFDFFFFFFFDFFFE; + ans = 64'h40CEFEF00000000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4098489\n"); + end + x = 64'h8028007FFFFFFFFF; + y = 64'h73208000000003FE; + z = 64'hFFEFFBFFC0000000; + ans = 64'hFFEFFBFFC0000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4100503\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'hC010000000000001; + z = 64'h4340000000000000; + ans = 64'h4340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4102517\n"); + end + x = 64'hC070000000024000; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hC1E0000004003FFE; + ans = 64'hC1DFFFFE08007FFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4104531\n"); + end + x = 64'h3F42000000000003; + y = 64'h37F22F335B65E2E0; + z = 64'h43C80000007FFFFF; + ans = 64'h43C80000007FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4106545\n"); + end + x = 64'hBFDFFFFFFFFFFFFF; + y = 64'hFFE0000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4108559\n"); + end + x = 64'h7FE040FFFFFFFFFF; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hE2E00003FE000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4110573\n"); + end + x = 64'hBFEA81733546F034; + y = 64'h2626E518F36926A1; + z = 64'hC09FFF7FFFF7FFFE; + ans = 64'hC09FFF7FFFF7FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4112587\n"); + end + x = 64'hBFDFFFFFFFFFFFFE; + y = 64'h0000000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4114601\n"); + end + x = 64'hBF2FF00000000003; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h8022000000FFFFFF; + ans = 64'h8022007FC0FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4116615\n"); + end + x = 64'h408FFFF0000007FF; + y = 64'h41D00000FFFFFFEF; + z = 64'hDC70402000000000; + ans = 64'hDC70402000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4118629\n"); + end + x = 64'hBFDFFFFFFFFFFFFE; + y = 64'h3CA0000000000000; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4120643\n"); + end + x = 64'hBE103FEFFFFFFFFF; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h62FFFF7FFFBFFFFF; + ans = 64'h62FFFF7FFFBFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4122657\n"); + end + x = 64'h43C2010000000000; + y = 64'h41D2FD2FF3E9D4A6; + z = 64'hB800000002040000; + ans = 64'h45A55E05C5664DD8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4124671\n"); + end + x = 64'hBFDFFFFFFFFFFFFE; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4126685\n"); + end + x = 64'h47E47B8A900D62AC; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hC01DB634A55C6312; + ans = 64'h47E47B8A900D62AB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4128699\n"); + end + x = 64'h41FC6E69D7DCEB33; + y = 64'hBFCFFFFFFF7FFFFE; + z = 64'h381FFFFFFFFFFFFF; + ans = 64'hC1DC6E69D76B318A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4130713\n"); + end + x = 64'hBFDFFFFFFFFFFFFE; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4132727\n"); + end + x = 64'h3FC00000FFFC0000; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h423D5A6FF0405C99; + ans = 64'h423D5A6FF040DC99; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4134741\n"); + end + x = 64'h47EFF000000001FE; + y = 64'h7FDFFFFFFFFFFEE0; + z = 64'h000FFFFDFDFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4136755\n"); + end + x = 64'hBFDFFFFFFFFFFFFE; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hC00FFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4138769\n"); + end + x = 64'hBFDFFFFFFB000000; + y = 64'h4340000000000001; + z = 64'h42B0007FFFEFFFFF; + ans = 64'hC32FDFFEFB002002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4140783\n"); + end + x = 64'h3FD7F06D69FF62BE; + y = 64'h2B5E7140250D5798; + z = 64'h42E778A05FEDF936; + ans = 64'h42E778A05FEDF936; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4142797\n"); + end + x = 64'hBFDFFFFFFFFFFFFE; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hFFDFFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4144811\n"); + end + x = 64'h3240900000000000; + y = 64'h7FF0000000000001; + z = 64'hC0600FF7FFFFFFFF; + 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,"4146825\n"); + end + x = 64'h43CFFFFFFFEFEFFF; + y = 64'hB9BFFFFEFFFFF7FF; + z = 64'h3FD066C1AC02AAC5; + ans = 64'h3FD066C1AC00AAC5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4148839\n"); + end + x = 64'hBFDFFFFFFFFFFFFE; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4150853\n"); + end + x = 64'h001FFFFFC07FFFFF; + y = 64'h8010000000000000; + z = 64'h02BE69A571E64868; + ans = 64'h02BE69A571E64868; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4152867\n"); + end + x = 64'hC801D6762B8F708B; + y = 64'hBFF000008000001F; + z = 64'hB26FF8000000FFFE; + ans = 64'h4801D676BA43220A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4154881\n"); + end + x = 64'hBFDFFFFFFFFFFFFE; + y = 64'hBCA0000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4156895\n"); + end + x = 64'h43CF6221B792A495; + y = 64'hBFD0000000000000; + z = 64'hB79000FFFFFFFFFF; + ans = 64'hC3AF6221B792A495; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4158909\n"); + end + x = 64'h434FFFFFFEFFE000; + y = 64'h402ECBE6EE1B4687; + z = 64'h3FC46C50F0C047D2; + ans = 64'h438ECBE6ED24C884; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4160923\n"); + end + x = 64'hBFDFFFFFFFFFFFFE; + y = 64'hBFE0000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h3FCFFFFFFFFFFFF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4162937\n"); + end + x = 64'hC02DFFFFFFFFFEFE; + y = 64'hBFF0000000000000; + z = 64'h49120007FFFFFFFE; + ans = 64'h49120007FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4164951\n"); + end + x = 64'h381FFFFFFFDFFFFF; + y = 64'hBFE020000000003F; + z = 64'hC01FFFFFFFFE0100; + ans = 64'hC01FFFFFFFFE0100; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4166965\n"); + end + x = 64'hBFDFFFFFFFFFFFFE; + y = 64'hC000000000000001; + z = 64'h3FF0000000000001; + ans = 64'h4000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4168979\n"); + end + x = 64'h801FFEFFFFFFEFFF; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h3FBFFFFFFFFEFF7E; + ans = 64'h3FBFFFFFFFFEFF7E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4170993\n"); + end + x = 64'hC0FFDFFFFFFE0000; + y = 64'h3F9FFFFF80000001; + z = 64'hC34FFFFFFF800000; + ans = 64'hC34FFFFFFF8007F8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4173007\n"); + end + x = 64'hBFDFFFFFFFFFFFFE; + y = 64'hC340000000000000; + z = 64'hC340000000000000; + ans = 64'hC330000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4175021\n"); + end + x = 64'hC02CF9D37F232E60; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h000FFFFFF8000040; + ans = 64'h438CF9D37F232E5E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4177035\n"); + end + x = 64'h0DE003FFF8000000; + y = 64'h41FBFFFFFFFFFFDE; + z = 64'h3E4D71A95D335306; + ans = 64'h3E4D71A95D335306; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4179049\n"); + end + x = 64'hBFDFFFFFFFFFFFFE; + y = 64'hFFF0000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4181063\n"); + end + x = 64'h41FFFFFC3FFFFFFE; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hC01A0C790AA8541A; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4183077\n"); + end + x = 64'hC080000000043FFF; + y = 64'h3E80000004007FFE; + z = 64'hC1C9224041A80188; + ans = 64'hC1C9224041A80388; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4185091\n"); + end + x = 64'hBFE0000000000000; + y = 64'h0010000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4187105\n"); + end + x = 64'h403FFFFFBDFFFFFF; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hDDFFFFFFFFFFFCFF; + ans = 64'hDDFFFFFFFFFFFCFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4189119\n"); + end + x = 64'hC3C0030000000000; + y = 64'h3FC0010000000004; + z = 64'hC0208000000001FF; + ans = 64'hC390040030000004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4191133\n"); + end + x = 64'hBFE0000000000000; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4193147\n"); + end + x = 64'hB07D269A66E4F2B6; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hBF500020000007FE; + ans = 64'hBF500020000007FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4195161\n"); + end + x = 64'h43CFFFFFFFFFFE01; + y = 64'hC34F7FFFBFFFFFFF; + z = 64'h43C0000000F7FFFF; + ans = 64'hC72F7FFFBFFFFE08; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4197175\n"); + end + x = 64'hBFE0000000000000; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4199189\n"); + end + x = 64'h801008007FFFFFFE; + y = 64'h3FF0000000000001; + z = 64'h447007F7FFFFFFFE; + ans = 64'h447007F7FFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4201203\n"); + end + x = 64'hBCA003FFFFFF0000; + y = 64'h400AC4372520559F; + z = 64'h3FCBD9E12AC2C108; + ans = 64'h3FCBD9E12AC2C0FB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4203217\n"); + end + x = 64'hBFE0000000000000; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4205231\n"); + end + x = 64'hC25FFEFFFFFEFFFF; + y = 64'h4010000000000001; + z = 64'h38067F748D1E9A72; + ans = 64'hC27FFEFFFFFF0001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4207245\n"); + end + x = 64'h4BB000040000003E; + y = 64'h318FFFFFFFFFF7FF; + z = 64'hBFE0000000000017; + ans = 64'hBFDFFFFFFFFFF02E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4209259\n"); + end + x = 64'hBFE0000000000000; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hC33FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4211273\n"); + end + x = 64'hC99FFF7800000000; + y = 64'h7FE0000000000001; + z = 64'hB7EFFF8000800000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4213287\n"); + end + x = 64'h47F7C717A1E0D326; + y = 64'h001FFFFFF00FFFFF; + z = 64'h00001FFFFFFFFFBE; + ans = 64'h0827C71796092AE0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4215301\n"); + end + x = 64'hBFE0000000000000; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4217315\n"); + end + x = 64'hF57FFFFFFFFFFFFF; + y = 64'h8000000000000000; + z = 64'hC97002FFFFFFFFFE; + ans = 64'hC97002FFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4219329\n"); + end + x = 64'hC1DFFFFDFFFFFEFF; + y = 64'h0773FFFF7FFFFFFE; + z = 64'h38100000001FF7FF; + ans = 64'h38100000001FF7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4221343\n"); + end + x = 64'hBFE0000000000000; + y = 64'h8010000000000001; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4223357\n"); + end + x = 64'hC3410000000003FF; + y = 64'hBCA0000000000000; + z = 64'h80100000FFFFF000; + ans = 64'h3FF10000000003FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4225371\n"); + end + x = 64'hC03FFEFFFFFFFDFF; + y = 64'h40BC282748CFC06D; + z = 64'hBF2FFFFEFDFFFFFE; + ans = 64'hC10C274608157828; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4227385\n"); + end + x = 64'hBFE0000000000000; + y = 64'hBFD0000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4229399\n"); + end + x = 64'hC3C1FFFFFFFFFFEE; + y = 64'hBFE0000000000000; + z = 64'h56200000000203FE; + ans = 64'h56200000000203FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4231413\n"); + end + x = 64'h489FEFFFFFFFFF00; + y = 64'h22FFF007FFFFFFFF; + z = 64'h43F1293689290D1A; + ans = 64'h43F1293689290D1A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4233427\n"); + end + x = 64'hBFE0000000000000; + y = 64'hBFF0000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3FE0000000000003; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4235441\n"); + end + x = 64'hC3D0000007FFFEFF; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h4343523E456566FF; + ans = 64'h43E004D497915858; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4237455\n"); + end + x = 64'h41DFFFE003FFFFFE; + y = 64'h3FF00003FFFFFF7E; + z = 64'h80067F5CA0F4F00E; + ans = 64'h41DFFFE803F7FFFA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4239469\n"); + end + x = 64'hBFE0000000000000; + y = 64'hC010000000000000; + z = 64'hBFF0000000000001; + ans = 64'h3FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4241483\n"); + end + x = 64'hB7FEF51E4B4DCBEF; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFAFFFF; + ans = 64'hBCAFFFFFFFFAFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4243497\n"); + end + x = 64'h47E30F7EC43AD2A9; + y = 64'h4020203FFFFFFFFE; + z = 64'h3FCF7FFFFFBFFFFF; + ans = 64'h481335E9FFBE5937; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4245511\n"); + end + x = 64'hBFE0000000000000; + y = 64'hFFE0000000000000; + z = 64'h4340000000000000; + ans = 64'h7FD0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4247525\n"); + end + x = 64'hB7EFEFFFFFFFFFF7; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hFFDD4FE4B235EA5D; + ans = 64'hFFDD4FE4B235EA5D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4249539\n"); + end + x = 64'hBFDFFFFFFFFFF81F; + y = 64'hC020007F80000000; + z = 64'h43EAB3830C35EB3F; + ans = 64'h43EAB3830C35EB3F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4251553\n"); + end + x = 64'hBFE0000000000000; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4253567\n"); + end + x = 64'hBFD23FFFFFFFFFFF; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h401FFFFDFFFFFFFF; + ans = 64'h401FFFFDFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4255581\n"); + end + x = 64'h480FFFFFFFFFE003; + y = 64'h3FCE71E027D1E6CF; + z = 64'h3D32000000001000; + ans = 64'h47EE71E027D1C860; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4257595\n"); + end + x = 64'hBFE0000000000001; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4259609\n"); + end + x = 64'h2580002000000100; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h380FFFFFFF7FDFFF; + ans = 64'h380FFFFFFF7FDFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4261623\n"); + end + x = 64'h3CA000000007F000; + y = 64'h43CDFFFBFFFFFFFE; + z = 64'hC80FFFFFEFFFFFE0; + ans = 64'hC80FFFFFEFFFFFE0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4263637\n"); + end + x = 64'hBFE0000000000001; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h3FE8000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4265651\n"); + end + x = 64'h000080000000007F; + y = 64'h3FE0000000000001; + z = 64'h3FBFFFFFFC00001E; + ans = 64'h3FBFFFFFFC00001E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4267665\n"); + end + x = 64'h3FFFFFFC00003FFF; + y = 64'hC1DD368E07D8CF94; + z = 64'h381FFFFFF0000008; + ans = 64'hC1ED368A61074905; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4269679\n"); + end + x = 64'hBFE0000000000001; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4271693\n"); + end + x = 64'h4070400000000100; + y = 64'h4000000000000001; + z = 64'h40300000001FF800; + ans = 64'h4080C000000100C1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4273707\n"); + end + x = 64'hB7E0000400000000; + y = 64'hC805546FB3FF2B69; + z = 64'h2F2007FFFFFFFC00; + ans = 64'h3FF55475091B1869; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4275721\n"); + end + x = 64'hBFE0000000000001; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4277735\n"); + end + x = 64'h40D00000000FFFEF; + y = 64'h4340000000000001; + z = 64'h401FFFFD7FFFFFFF; + ans = 64'h44200000000FFFF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4279749\n"); + end + x = 64'h556FFFE000000400; + y = 64'hBF900800000003FF; + z = 64'hBD3FEFFEFFFFFFFF; + ans = 64'hD51007EFF8000600; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4281763\n"); + end + x = 64'hBFE0000000000001; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hFFE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4283777\n"); + end + x = 64'h4006E2164F181ABB; + y = 64'h7FF0000000000000; + z = 64'h37F0800000000008; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4285791\n"); + end + x = 64'h398FFFFFFFFBFFC0; + y = 64'hC0A783C6E834743B; + z = 64'h381FFFFFFFFEF000; + ans = 64'hBA4783C6E82D8393; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4287805\n"); + end + x = 64'hBFE0000000000001; + y = 64'h8000000000000001; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4289819\n"); + end + x = 64'h37FEFFFFFF800000; + y = 64'h8010000000000000; + z = 64'hBFFFF80007FFFFFE; + ans = 64'hBFFFF80007FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4291833\n"); + end + x = 64'h415FFFE0000001FF; + y = 64'hC1CFFFF77FFFFFFF; + z = 64'h47F0200000000FFE; + ans = 64'h47F0200000000FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4293847\n"); + end + x = 64'hBFE0000000000001; + y = 64'hBCA0000000000001; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4295861\n"); + end + x = 64'h3DAFFFFFEFFE0000; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h9E4FFF0000FFFFFF; + ans = 64'hBA6FFFFFEFFDFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4297875\n"); + end + x = 64'hFC840001FFFFFFFF; + y = 64'hBFF003FFFFFFFFFE; + z = 64'hB7F000000004000F; + ans = 64'h7C840502007FFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4299889\n"); + end + x = 64'hBFE0000000000001; + y = 64'hBFE0000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4301903\n"); + end + x = 64'h3FD007DFFFFFFFFE; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hBFC5181D7BDE39EF; + ans = 64'hBFDA93EEBDEF1CF4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4303917\n"); + end + x = 64'h303018350289038C; + y = 64'hE68FFFFFFFFFDFEF; + z = 64'hB80FC00020000000; + ans = 64'hD6D018350288F36B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4305931\n"); + end + x = 64'hBFE0000000000001; + y = 64'hC000000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h3FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4307945\n"); + end + x = 64'hBF5FE0000000001F; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hC34FEFFC00000000; + ans = 64'hC34FEFFC00000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4309959\n"); + end + x = 64'h3FE123613DB144E9; + y = 64'h42E07FFFFF7FFFFF; + z = 64'h7FD00FFFFFF7FFFF; + ans = 64'h7FD00FFFFFF7FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4311973\n"); + end + x = 64'hBFE0000000000001; + y = 64'hC340000000000000; + z = 64'h3FF0000000000001; + ans = 64'h4330000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4313987\n"); + end + x = 64'h3CA0000007FC0000; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h42D20F3B307165CC; + ans = 64'h42D20F3B3071654C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4316001\n"); + end + x = 64'hC1EFFFE00000003E; + y = 64'h43D0001FFFFC0000; + z = 64'hFFEC761D088A43AC; + ans = 64'hFFEC761D088A43AC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4318015\n"); + end + x = 64'hBFE0000000000001; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'h7FE0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4320029\n"); + end + x = 64'hC0B2F9F4C13E948F; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h7FFD22CA98E89510; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4322043\n"); + end + x = 64'h40304125AC71B55E; + y = 64'h41CFFFFFFBFFFFEE; + z = 64'h47FFFFFFFFFFFFBF; + ans = 64'h47FFFFFFFFFFFFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4324057\n"); + end + x = 64'hBFEFFFFFFFFFFFFF; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4326071\n"); + end + x = 64'hC48010007FFFFFFF; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h7FDFFFFFFFFFC03F; + ans = 64'h7FDFFFFFFFFFC03F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -331344,10 +101042,10 @@ initial if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); $fwrite(fp,"4328085\n"); end - xrf = 64'h403000001FBFFFFE; - y = 64'hBF7FFFE800000000; - zrf = 64'h4355B251B630D4CF; - ans = 64'h4355B251B630D4CF; + x = 64'h4120000010003FFF; + y = 64'hBFB0000000028000; + z = 64'h3FF0000001F7FFFF; + ans = 64'hC0DFFFC02005781E; rn = 1; rz = 0; rm = 0; @@ -331361,19 +101059,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -331389,12 +101087,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4328699\n"); + $fwrite(fp,"4330099\n"); end - xrf = 64'hBC7FFFFDFFFF7FFF; - y = 64'h0000000000000001; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; + x = 64'hBFEFFFFFFFFFFFFF; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h396FFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -331408,19 +101106,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -331436,717 +101134,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4329313\n"); + $fwrite(fp,"4332113\n"); end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h403FFFE000001FFF; - zrf = 64'hC0003FFFFFFFFFF7; - ans = 64'hC04103F000000FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4329927\n"); - end - xrf = 64'h43EFBFFFFFFF7FFF; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h3FD00000080007FF; - ans = 64'h3FD00000080007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4330541\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h424BFFFFFFFFFFFC; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hC24C000000007FFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4331155\n"); - end - xrf = 64'hFD20000000200008; - y = 64'h000D502826CFDCE5; - zrf = 64'h41EFFFFFF7FFFFFA; - ans = 64'h41EFFFFFF7FFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4331769\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h0010000000000001; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h3FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4332383\n"); - end - xrf = 64'h381B30628BB47600; - y = 64'h356FFFFFFFFFFFFE; - zrf = 64'h0010000000000000; - ans = 64'h2D9B30628BB475FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4332997\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h437FFFBFBFFFFFFE; - ans = 64'h437FFFBFBFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4333611\n"); - end - xrf = 64'hB7F0000001FFF7FF; - y = 64'h41D36C3E5F5E6774; - zrf = 64'h7FFB723D92EAFB7E; - ans = 64'h7FFB723D92EAFB7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4334225\n"); - end - xrf = 64'hFFFFFFFFFFFFFF5E; - y = 64'h3CA0000000000000; - zrf = 64'h4340000000000000; - ans = 64'hFFFFFFFFFFFFFF5E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4334839\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h451B198878C05209; - zrf = 64'h43E92C254308D244; - ans = 64'hC51B1985533BA9A7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4335453\n"); - end - xrf = 64'hB81FFFFFFFBFFFBF; - y = 64'h3CA0000000000001; - zrf = 64'h53C0000003DFFFFF; - ans = 64'h53C0000003DFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4336067\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h3800000008000800; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4336681\n"); - end - xrf = 64'hC030000800000FFF; - y = 64'hC80FC3FFFFFFFFFE; - zrf = 64'h3878A4F937BB209B; - ans = 64'h484FC40FE2001FC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4337295\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h3FD0000000000000; - zrf = 64'h3FF0000000000000; - ans = 64'h3FE8000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4337909\n"); - end - xrf = 64'hB7E61060ABCDAFA7; - y = 64'h3F3FFFFFFC001000; - zrf = 64'h0000000000000001; - ans = 64'hB7361060A90BAE9A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4338523\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; + x = 64'h37FFFFFFFFFFFEFD; y = 64'h3FD0000000000001; - zrf = 64'hC0E0003FFFFFFEFE; - ans = 64'hC0E00047FFFFFEFE; + z = 64'h40EE00000007FFFE; + ans = 64'h40EE00000007FFFE; rn = 1; rz = 0; rm = 0; @@ -332160,19 +101153,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -332188,12 +101181,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4339137\n"); + $fwrite(fp,"4334127\n"); end - xrf = 64'h00000203FFFFFFFE; - y = 64'h45F00000800FFFFF; - zrf = 64'hB80FFFFFE000FFFE; - ans = 64'hB80FFFFFE000FFFE; + x = 64'h41F0000007FFDFFF; + y = 64'hC80FFC0000FFFFFE; + z = 64'hB81046EFCDE22968; + ans = 64'hCA0FFC0010FDC005; rn = 1; rz = 0; rm = 0; @@ -332207,19 +101200,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -332235,12 +101228,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4339751\n"); + $fwrite(fp,"4336141\n"); end - xrf = 64'h41DF80000000003E; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h4010000000000001; - ans = 64'h41CF80000200003C; + x = 64'hBFEFFFFFFFFFFFFF; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hC000000000000000; rn = 1; rz = 0; rm = 0; @@ -332254,19 +101247,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -332282,5699 +101275,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4340365\n"); + $fwrite(fp,"4338155\n"); end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hC020FFFFFFFFFFDF; - zrf = 64'h3615508CD1EEBB35; - ans = 64'h4020FFFFFFFFFFDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4340979\n"); - end - xrf = 64'h4010000004000004; - y = 64'h3FE0000000000000; - zrf = 64'hB7E000004FFFFFFF; - ans = 64'h4000000004000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4341593\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h3CAFEFFFFF800000; - zrf = 64'hBFD0000000000001; - ans = 64'hBFD0000000000005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4342207\n"); - end - xrf = 64'hE5C6DF41AD077F3E; - y = 64'h400FF3ABA5F79A34; - zrf = 64'hBFD0047FFFFFFFFF; - ans = 64'hE5E6D671AA004CF1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4342821\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h3FE0000000000001; - ans = 64'hBFDFFFFFFFFFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4343435\n"); - end - xrf = 64'h800B03D2F82518FD; - y = 64'h433FFFFFF87FFFFF; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4344049\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h3FF0000000000000; - zrf = 64'h3CA000000087FFFF; - ans = 64'hBFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4344663\n"); - end - xrf = 64'hBFC00001FFEFFFFF; - y = 64'h4011FDFFFFFFFFFF; - zrf = 64'h3EFF0000007FFFFF; - ans = 64'hBFE1FDC43FAE00FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4345277\n"); - end - xrf = 64'hC05D6E5422AAD3D6; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'hC06CEE5422AAD3D5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4345891\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h2F19AE115658A653; - zrf = 64'hC1EFFFFFDFF7FFFF; - ans = 64'hC1EFFFFFDFF7FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4346505\n"); - end - xrf = 64'hBFBFFFFFFBBFFFFE; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hC1FFFFFFFFFFFF5F; - ans = 64'hC20000000001FFAF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4347119\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hC10E000000040000; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h410E00000003FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4347733\n"); - end - xrf = 64'h3F20000000003FFE; - y = 64'h3817FFFFC0000000; - zrf = 64'h3A3FFFFF00000FFE; - ans = 64'h3A3FFFFF0000102E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4348347\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'hC00BFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4348961\n"); - end - xrf = 64'hC4F000000000021E; - y = 64'h4C20200FFFFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4349575\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hB7EFFE0007FFFFFE; - ans = 64'hC00FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4350189\n"); - end - xrf = 64'hC1FFFFFFFFEFDFFF; - y = 64'hBA6BFFFFFFEFFFFF; - zrf = 64'hC0000001FFFFFFFB; - ans = 64'hC0000001FFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4350803\n"); - end - xrf = 64'h37E8ACA8DE60299C; - y = 64'h4010000000000001; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h3FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4351417\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hC1CFFFFC7FFFFFFF; - zrf = 64'h434FFF7FF7FFFFFF; - ans = 64'h434FFF8017FFFC7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4352031\n"); - end - xrf = 64'hC010000FFFFFFF80; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h403E000001FFFFFF; - ans = 64'hC00000FFEFFFF800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4352645\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h3F8FFFFF7FDFFFFF; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'hBF8FFFFF7FDFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4353259\n"); - end - xrf = 64'h0010003FFFFF0000; - y = 64'hC7EFFFFFFFFF7FE0; - zrf = 64'h801FFFFF07FFFFFF; - ans = 64'h8810003FFFFEBFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4353873\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h4340000000000001; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4354487\n"); - end - xrf = 64'hC7A0000043FFFFFF; - y = 64'hC3D0000000001200; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4355101\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h400FFFFFFF3FFFFF; - ans = 64'hC34FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4355715\n"); - end - xrf = 64'h3FC3EFFFFFFFFFFF; - y = 64'h131EFFFFFFFBFFFE; - zrf = 64'h372FFFFFFFFDFFBF; - ans = 64'h372FFFFFFFFDFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4356329\n"); - end - xrf = 64'hD05FFFFFFFFFE004; - y = 64'h7FE0000000000000; - zrf = 64'h3FF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4356943\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h3FFFFFEFBFFFFFFF; - zrf = 64'h3FC100000000007F; - ans = 64'hBFFDDFEFBFFFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4357557\n"); - end - xrf = 64'hDB70000000000108; - y = 64'h7FE0000000000001; - zrf = 64'hC0001FFFFFF7FFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4358171\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hBFDA92E29E1DBB28; - zrf = 64'h8010000000000000; - ans = 64'h3FDA92E29E1DBB27; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4358785\n"); - end - xrf = 64'hC1E00FFFFFF80000; - y = 64'h419FFFFFFF7E0000; - zrf = 64'hC800000000000002; - ans = 64'hC800000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4359399\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h7FF0000000000000; - zrf = 64'h3CA0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4360013\n"); - end - xrf = 64'hFFDFF00001FFFFFF; - y = 64'h3EEFFFF7FFDFFFFE; - zrf = 64'hC340000000000001; - ans = 64'hFEDFEFF805E00F7D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4360627\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h7FF0000000000001; - zrf = 64'h403000800FFFFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4361241\n"); - end - xrf = 64'hFFFFDFFFBFFFFFFF; - y = 64'h41E0200004000000; - zrf = 64'h3FBFF0000FFFFFFE; - ans = 64'hFFFFDFFFBFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4361855\n"); - end - xrf = 64'hC03FFFFF7FFFFE00; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h3FE0000000000001; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4362469\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hC3DFE0EC008812C4; - zrf = 64'hC3C000000000403F; - ans = 64'h43D7E0EC0087F2A4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4363083\n"); - end - xrf = 64'h8AAFFFFFFFE0000E; - y = 64'h8000000000000000; - zrf = 64'h4300000FFFFFFFF8; - ans = 64'h4300000FFFFFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4363697\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hBFD00002000007FF; - zrf = 64'h8000000000000001; - ans = 64'h3FD00002000007FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4364311\n"); - end - xrf = 64'hC03B9BB0387EBCB7; - y = 64'h4DFFFFFF6FFFFFFE; - zrf = 64'h3B5FC00020000000; - ans = 64'hCE4B9BAFBC4223B7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4364925\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h0010000000000001; - ans = 64'h001FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4365539\n"); - end - xrf = 64'hC4706C92F0C04121; - y = 64'hB7FBFFFFFFF00000; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4366153\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h8010000000000000; - zrf = 64'h3FBFFBFFFFFF8000; - ans = 64'h3FBFFBFFFFFF8000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4366767\n"); - end - xrf = 64'h4F28A5328EF31365; - y = 64'h3BB5EEB72C018E2F; - zrf = 64'h3800003FFFFF7FFF; - ans = 64'h4AF0E442E8742E48; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4367381\n"); - end - xrf = 64'hC0002007FFFFFFFF; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4367995\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h3F8FFFDFFFFFBFFF; - zrf = 64'h3FFFFFFFF800000F; - ans = 64'h3FFFC0003800008F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4368609\n"); - end - xrf = 64'h43E0220000000000; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h70B00FF800000000; - ans = 64'h70B00FF800000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4369223\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hBFFFFFFFFE0007FE; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4369837\n"); - end - xrf = 64'hBD827E97994884F1; - y = 64'hB9AFFFFFFFFFFFFF; - zrf = 64'hB86FFFDFFFDFFFFE; - ans = 64'hB86FFFDB603A19AC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4370451\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4371065\n"); - end - xrf = 64'h41DFFFFFFFBFEFFE; - y = 64'hBF2A4F4D041B97F4; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC11A4F5D03E6EC31; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4371679\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hBFB0080001FFFFFF; - ans = 64'hBFB0080001FFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4372293\n"); - end - xrf = 64'h4B92DA8046BE5733; - y = 64'hBF0FFFFFE00003FF; - zrf = 64'h3FEFDEFFFFFFFFFF; - ans = 64'hCAB2DA8033E3D947; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4372907\n"); - end - xrf = 64'hC3297D1EB423F8D1; - y = 64'hBFD0000000000001; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h43097D1EB423F8D3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4373521\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h3FBFFFFFDFFFEFFF; - zrf = 64'hC7600DFFFFFFFFFF; - ans = 64'hC7600DFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4374135\n"); - end - xrf = 64'hBFBFFFFFFFFFDDFE; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h41B9B4DD9B358499; - ans = 64'h41B9B4DD9B458499; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4374749\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hC14C85D57EAED327; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4375363\n"); - end - xrf = 64'hBD8FFFFFFFFF07FF; - y = 64'hFFEE1DA0618D53A8; - zrf = 64'h7FD215ED10F23F9A; - ans = 64'h7FD215ED10F33087; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4375977\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hBFE0000000000000; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4376591\n"); - end - xrf = 64'hBCA000001000FFFF; - y = 64'hCB307FFFFFFE0000; - zrf = 64'hC000000000000000; - ans = 64'h47E08000107F07FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4377205\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h403FFFFFFFFFF000; - ans = 64'h40407FFFFFFFF800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4377819\n"); - end - xrf = 64'hC0000FFFFFFBFFFE; - y = 64'hC7F1FEFFFFFFFFFE; - zrf = 64'h434FFFFFE00007FF; - ans = 64'h480210FEFFFB803C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4378433\n"); - end - xrf = 64'hC2B00001000007FE; - y = 64'hBFF0000000000000; - zrf = 64'h3CA0000000000000; - ans = 64'h42B00001000007FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4379047\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hBF43F7D1712E3D7A; - zrf = 64'h37EFFFFF7FF80000; - ans = 64'h3F43F7D1712E3D79; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4379661\n"); - end - xrf = 64'hB80FFFFFF1FFFFFE; - y = 64'hBFF0000000000001; - zrf = 64'h402FFFFFFFFC1FFF; - ans = 64'h402FFFFFFFFC1FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4380275\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hBDF03FFFFFFFFFFB; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4380889\n"); - end - xrf = 64'hFFF0800000000FFE; - y = 64'hDC8FFFF7FFFFFF00; - zrf = 64'hBFB0000000000FBE; - ans = 64'hFFF8800000000FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4381503\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4382117\n"); - end - xrf = 64'h4680004007FFFFFF; - y = 64'h315FFFFFFFFEEFFE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4382731\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hC000000000000001; - zrf = 64'hBF7FFFFFFFF803FF; - ans = 64'h3FFFE000000007FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4383345\n"); - end - xrf = 64'hC016CA6F50826588; - y = 64'hCBF0000803FFFFFE; - zrf = 64'h403FBFFFF7FFFFFE; - ans = 64'h4C16CA7ABB6CA99A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4383959\n"); - end - xrf = 64'h47FFFFFFFFFF81FF; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h0010000000000001; - ans = 64'hC81FFFFFFFFF81FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4384573\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h41C37FFFFFFFFFFF; - zrf = 64'hC02FFEFFFFFFE000; - ans = 64'hC1C3800007FFBFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4385187\n"); - end - xrf = 64'h47EFFFDFFFFFF7FE; - y = 64'hC010000000000000; - zrf = 64'h41FFFFFB80000000; - ans = 64'hC80FFFDFFFFFF7FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4385801\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h43C4CA093D43DE93; - zrf = 64'h4340000000000001; - ans = 64'hC3C4BA093D43DE92; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4386415\n"); - end - xrf = 64'h41E0100000007FFF; - y = 64'hC3400800000007FF; - zrf = 64'h3FFFC000003FFFFF; - ans = 64'hC530180800008846; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4387029\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4387643\n"); - end - xrf = 64'hBFD7FFFFFFC00000; - y = 64'hBFE07659F20E5913; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFE9D39E454B14F2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4388257\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hC340000000000000; - zrf = 64'hB8000803FFFFFFFF; - ans = 64'h433FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4388871\n"); - end - xrf = 64'h3FF000001FFFFFBF; - y = 64'hC0AFFF007FFFFFFE; - zrf = 64'h7FDFF000000001FF; - ans = 64'h7FDFF000000001FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4389485\n"); - end - xrf = 64'hC1C755F6FA1F7B9C; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h452755F6FA1F7B9B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4390099\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h3FBEADE2ED7F2A49; - zrf = 64'hBFDFFE0000000010; - ans = 64'hBFE3D4BC5DAFE551; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4390713\n"); - end - xrf = 64'hC1CFEFF800000000; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hC1FE2C7C2859E57D; - ans = 64'h452FEFF7FFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4391327\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h3FEFDF8000000000; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h401C040FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4391941\n"); - end - xrf = 64'h83C000001FF7FFFF; - y = 64'h3B600010000FFFFE; - zrf = 64'hC0700000040003FE; - ans = 64'hC0700000040003FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4392555\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hFFE0000000000001; - zrf = 64'hC34FFFFFFFFFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4393169\n"); - end - xrf = 64'hC5AFFC0001FFFFFF; - y = 64'h98D45F742397F0ED; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4393783\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h4020000800000000; - ans = 64'h7FEFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4394397\n"); - end - xrf = 64'hC1F00000000FFBFF; - y = 64'h3CA00000004003FE; - zrf = 64'hC00FD0EE5011898E; - ans = 64'hC00FD0EE9011898F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4395011\n"); - end - xrf = 64'h41F076A618025E7D; - y = 64'hFFF0000000000000; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4395625\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'h43D000040003FFFE; - zrf = 64'hAA811161C04CBA71; - ans = 64'hC3D000040003FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4396239\n"); - end - xrf = 64'hC1E00000003FFFF0; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hC3D87C60F2B59E5B; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4396853\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFF; - y = 64'hC1D007FDFFFFFFFF; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h41D007FE00FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4397467\n"); - end - xrf = 64'h3FD00000000001C0; - y = 64'h37EFDFFFFF7FFFFF; - zrf = 64'hB81DB0CBA2FAF7A3; - ans = 64'hB81CB1CBA2FEF787; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4398081\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h0000000000000000; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4398695\n"); - end - xrf = 64'h800FFFFFFFC00007; - y = 64'h43C0001FFFFF0000; - zrf = 64'hBFD0000000000000; - ans = 64'hBFD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4399309\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h3F8FC0000007FFFF; - ans = 64'h3F8FC0000007FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4399923\n"); - end - xrf = 64'hC02714D43C1532E4; - y = 64'hB80E000100000000; - zrf = 64'hD50000002FFFFFFF; - ans = 64'hD50000002FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4400537\n"); - end - xrf = 64'hC01EFFFFFFFF7FFF; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4401151\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h3FD08000000007FF; - zrf = 64'h7FD8EC0DBC41EC75; - ans = 64'h7FD8EC0DBC41EC75; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4401765\n"); - end - xrf = 64'hBCAFFF4000000000; - y = 64'h0010000000000001; - zrf = 64'hC1B00004000007FF; - ans = 64'hC1B00004000007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4402379\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h386FE00000000004; - zrf = 64'h4000000000000000; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4402993\n"); - end - xrf = 64'h43F0000000027FFF; - y = 64'hBFB0000000004FFF; - zrf = 64'h04CE9D83A7B02979; - ans = 64'hC3B000000002CFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4403607\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4404221\n"); - end - xrf = 64'hBFDF80000000FFFE; - y = 64'h43F857FFAEF4CA4A; - zrf = 64'hBCA0000000000001; - ans = 64'hC3E7F69FB039B9DF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4404835\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h3CA0000000000001; - zrf = 64'h3BC0100000800000; - ans = 64'hBC9FFF7F7FFFFC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4405449\n"); - end - xrf = 64'hEE10100001FFFFFF; - y = 64'h3FB512E9F747CC1A; - zrf = 64'hC7ED044079DDB258; - ans = 64'hEDD527FCE3E17124; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4406063\n"); - end - xrf = 64'hA0B000FFFFFFFFFA; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4406677\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hBE5FC003FFFFFFFF; - zrf = 64'hBE5080001FFFFFFF; - ans = 64'h3E4E8007BFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4407291\n"); - end - xrf = 64'h428FC0001FFFFFFE; - y = 64'h3FD0000000000000; - zrf = 64'h7FE004000000003E; - ans = 64'h7FE004000000003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4407905\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hC07772ADE4344DA9; - zrf = 64'h3FF0000000000001; - ans = 64'h407782ADE4344DA8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4408519\n"); - end - xrf = 64'h395FF801FFFFFFFF; - y = 64'hC8EFFFF7FFFFFBFF; - zrf = 64'h401007FFFFFFEFFE; - ans = 64'hC25FF7FA01FE7B7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4409133\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hC000000000000001; - ans = 64'hC004000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4409747\n"); - end - xrf = 64'h47FF3FFFFFFFFFFE; - y = 64'h9A7FFFFFFFFFE07E; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'hA28F3FFFFFFFE139; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4410361\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h3FE0000000000000; - zrf = 64'h80100047FFFFFFFF; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4410975\n"); - end - xrf = 64'hBD20000000003FDE; - y = 64'hC7E0008000000010; - zrf = 64'hC1FFFFFFF00FFFFE; - ans = 64'h4510008000003FE8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4411589\n"); - end - xrf = 64'hC00003FFFFDFFFFF; - y = 64'h3FE0000000000001; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC350000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4412203\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hFB626BA02882A3F2; - zrf = 64'hC9C0000000000BFF; - ans = 64'h7B626BA02882A3F1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4412817\n"); - end - xrf = 64'h4070101FFFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'hC3E00000011FFFFF; - ans = 64'hC3E00000011FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4413431\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hBD5FFFFFEFFFFFEF; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FF00000000007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4414045\n"); - end - xrf = 64'h4024002000000000; - y = 64'h41F00007FFFFFEFF; - zrf = 64'h402D54ECA2BD5EFC; - ans = 64'h4224002A002D53AB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4414659\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; + x = 64'h3CCFFFFFDFFFFFBF; y = 64'h3FF0000000000001; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hC007FFFFFFFFFFFF; + z = 64'h00000000FFFFFFFC; + ans = 64'h3CCFFFFFDFFFFFC1; rn = 1; rz = 0; rm = 0; @@ -337988,19 +101294,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -338016,12 +101322,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4415273\n"); + $fwrite(fp,"4340169\n"); end - xrf = 64'h3CABFFFFFFFFFFF6; - y = 64'h0DC3FF7FFFFFFFFF; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h0A817F8FFFFFFFF9; + x = 64'h3C0FFFFFF7FBFFFF; + y = 64'h380FF001FFFFFFFE; + z = 64'h7FE0080003FFFFFF; + ans = 64'h7FE0080003FFFFFF; rn = 1; rz = 0; rm = 0; @@ -338035,19 +101341,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -338063,200 +101369,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4415887\n"); + $fwrite(fp,"4342183\n"); end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hBFBCC6EB52AFD717; - ans = 64'hC000E6375A957EB7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4416501\n"); - end - xrf = 64'hBDFFEFFFFFFFFFC0; - y = 64'h43DFFFFFFFFFF003; - zrf = 64'h7FD614D9A3184ED0; - ans = 64'h7FD614D9A3184ED0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4417115\n"); - end - xrf = 64'hC3C00000001FFFF7; - y = 64'h4000000000000000; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC3D00000001FFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4417729\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h0008E2EB3C72DBCD; - zrf = 64'h45300020000FFFFF; - ans = 64'h45300020000FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4418343\n"); - end - xrf = 64'h381EFFFFFFFEFFFF; + x = 64'hBFEFFFFFFFFFFFFF; y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h47F03FFFFFDFFFFE; - ans = 64'h47F03FFFFFDFFFFE; + z = 64'h4340000000000000; + ans = 64'h433FFFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -338270,19 +101388,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -338298,106 +101416,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4418957\n"); + $fwrite(fp,"4344197\n"); end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hC020000000200000; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h40210000001FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4419571\n"); - end - xrf = 64'h21CFFBFFFFFF0000; - y = 64'h45D19B17AC9C0AFD; - zrf = 64'hBF207FFFFFFFFFFC; - ans = 64'hBF207FFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4420185\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; + x = 64'hC1FFFFFFFFFFEEFE; y = 64'h4010000000000000; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hC013FFFFFFFFFFFF; + z = 64'h3DCD0691292BF78D; + ans = 64'hC21FFFFFFFFFEEFE; rn = 1; rz = 0; rm = 0; @@ -338411,19 +101435,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -338439,12 +101463,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4420799\n"); + $fwrite(fp,"4346211\n"); end - xrf = 64'hB81FFFFFFFFFEFDF; - y = 64'hFFF1A46C1D2E08E5; - zrf = 64'h8000000000000000; - ans = 64'hFFF9A46C1D2E08E5; + x = 64'h3FB101FFFFFFFFFE; + y = 64'hB7FFFFFFBEFFFFFF; + z = 64'h4040000008001FFF; + ans = 64'h4040000008001FFF; rn = 1; rz = 0; rm = 0; @@ -338458,19 +101482,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -338486,200 +101510,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4421413\n"); + $fwrite(fp,"4348225\n"); end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hC01FEFFFFFFFFFFC; - ans = 64'hC02FF7FFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4422027\n"); - end - xrf = 64'h41CFFFFE000007FF; - y = 64'h3FEFFF000FFFFFFF; - zrf = 64'h3ED0000000480000; - ans = 64'h41CFFEFE1010071E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4422641\n"); - end - xrf = 64'h801F000000020000; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4423255\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h3ECC000000000000; - zrf = 64'h422FFFFFFFFFFE08; - ans = 64'h422FFFFFFFFFFE08; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4423869\n"); - end - xrf = 64'hC00BF96CAEF8FF74; + x = 64'hBFEFFFFFFFFFFFFF; y = 64'h4340000000000001; - zrf = 64'h3FC000000400000F; - ans = 64'hC35BF96CAEF8FF76; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -338693,19 +101529,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -338721,12 +101557,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4424483\n"); + $fwrite(fp,"4350239\n"); end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h41EFFFFFFFDFFBFF; - zrf = 64'h3FD0000000000000; - ans = 64'hC1EFFFFFFFD7FBFD; + x = 64'h3FE0EFFFFFFFFFFE; + y = 64'h7FE0000000000000; + z = 64'hC0F00000001000FF; + ans = 64'h7FD0EFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -338740,19 +101576,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -338768,12 +101604,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4425097\n"); + $fwrite(fp,"4352253\n"); end - xrf = 64'h451FFFFFFFFE3FFE; - y = 64'h4023FFFFFFFBFFFE; - zrf = 64'hBFD000000001FF00; - ans = 64'h4553FFFFFFFAE7FD; + x = 64'h433FEFF7FFFFFFFF; + y = 64'h43EB97EE9E7AD837; + z = 64'h802FC08000000000; + ans = 64'h473B8A1BC12FF32B; rn = 1; rz = 0; rm = 0; @@ -338787,19 +101623,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -338815,58 +101651,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4425711\n"); + $fwrite(fp,"4354267\n"); end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hBFE0000000000000; - ans = 64'hC34FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4426325\n"); - end - xrf = 64'h3FFFFFF80000001F; - y = 64'hBCA000000000FFFB; - zrf = 64'h7FF0000000000001; + x = 64'hBFEFFFFFFFFFFFFF; + y = 64'h7FF0000000000001; + z = 64'hBCAFFFFFFFFFFFFF; ans = 64'h7FF8000000000001; rn = 1; rz = 0; @@ -338881,19 +101670,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -338909,435 +101698,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4426939\n"); + $fwrite(fp,"4356281\n"); end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h7FE0000000000001; - zrf = 64'h3FA4000000001FFF; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4427553\n"); - end - xrf = 64'h480FFFFFFFF7FFFB; - y = 64'hCDCFFFE00001FFFE; - zrf = 64'hA3393CEE0DB7E647; - ans = 64'hD5EFFFDFFFFA0001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4428167\n"); - end - xrf = 64'hFB70004000000000; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hC000000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4428781\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hBECFFEFFFFFFFC00; - zrf = 64'h3FE0007FFFFFFBFF; - ans = 64'h3FE00087FFBFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4429395\n"); - end - xrf = 64'h405FFFFFFFFFC3FF; - y = 64'h7FF0000000000000; - zrf = 64'h37E0000007FFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4430009\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hC3400FF7FFFFFFFE; - zrf = 64'h3CA0000000000001; - ans = 64'h43400FF7FFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4430623\n"); - end - xrf = 64'h3FBFFDFFBFFFFFFF; - y = 64'hD211FFFBFFFFFFFF; - zrf = 64'hBFEFFFFFFFFFC1FE; - ans = 64'hD1E1FEDBDC4007FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4431237\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'hBFD0000000000001; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4431851\n"); - end - xrf = 64'h3F400002FFFFFFFF; - y = 64'h47F639B9FF2EE66D; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4432465\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; + x = 64'hBFEFFFFF7FFFFFFA; y = 64'h8000000000000000; - zrf = 64'h381FFFFFE0001FFE; - ans = 64'h381FFFFFE0001FFE; + z = 64'hC9D51348049C8AC5; + ans = 64'hC9D51348049C8AC5; rn = 1; rz = 0; rm = 0; @@ -339351,19 +101717,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -339379,12 +101745,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4433079\n"); + $fwrite(fp,"4358295\n"); end - xrf = 64'h802FFFFFFE040000; - y = 64'h43CFFFEFFFF00000; - zrf = 64'h3FDFFFFFDBFFFFFF; - ans = 64'h3FDFFFFFDBFFFFFF; + x = 64'hCF7FFFFFFC07FFFE; + y = 64'h4DA00400FFFFFFFE; + z = 64'hBA5FFBFFFFFFFFFF; + ans = 64'hDD300400FE0380DD; rn = 1; rz = 0; rm = 0; @@ -339398,19 +101764,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -339426,1186 +101792,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4433693\n"); + $fwrite(fp,"4360309\n"); end - xrf = 64'hBFD000000207FFFF; - y = 64'h8000000000000001; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4434307\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h3FEE001000000000; - zrf = 64'h0010087FFFFFFFFF; - ans = 64'hBFEE000FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4434921\n"); - end - xrf = 64'hC1601FFFFFFFFF7F; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h7FE00000FFFF8000; - ans = 64'h7FE00000FFFF8000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4435535\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h3FB0000001000FFF; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'hBFB0000001000FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4436149\n"); - end - xrf = 64'hC0001FFFFFFFFFFF; - y = 64'h8CC4931394F7B5D0; - zrf = 64'hB810800000100000; - ans = 64'hB810800000100000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4436763\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; + x = 64'hBFEFFFFFFFFFFFFF; y = 64'h8010000000000001; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4437377\n"); - end - xrf = 64'h3FEBFDFFFFFFFFFE; - y = 64'hE13FFFFFFFEFFFFE; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'hE13BFDFFFFF200FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4437991\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'hBB3FFFFFFFFDFFE0; - ans = 64'hBB3FFFFFFFFDFFE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4438605\n"); - end - xrf = 64'h40300001FFBFFFFF; - y = 64'h4B707FFFFFFBFFFE; - zrf = 64'h4804965E33D8BBDF; - ans = 64'h4BB080020FB9FFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4439219\n"); - end - xrf = 64'h7FE003FFFFFBFFFF; - y = 64'hBCA0000000000000; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hFC9003FFFFFBFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4439833\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h403E85C37F705A7D; - zrf = 64'h4020000001FFFFFF; - ans = 64'hC03685C37E705A7C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4440447\n"); - end - xrf = 64'h41F9048C841E6F9F; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'hC3D000000003FFFF; - ans = 64'hC3D000000003FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4441061\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hC04FFFFF7FF7FFFE; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h404FFFFF7FF7FFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4441675\n"); - end - xrf = 64'h497000FFEFFFFFFF; - y = 64'hB1D15A7CDF712406; - zrf = 64'h37E54B45EEC51223; - ans = 64'hBB515B9275E49E38; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4442289\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hBFD0000000000000; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h3FCFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4442903\n"); - end - xrf = 64'h43CFFF00003FFFFE; - y = 64'h41CFFFFEFFFFFDFF; - zrf = 64'h4340000000000000; - ans = 64'h45AFFEFF00483DFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4443517\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h4028F639F9738560; - ans = 64'h4029F639F9738560; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4444131\n"); - end - xrf = 64'h15F0800000000003; - y = 64'h38D080000003FFFE; - zrf = 64'h75E7946160589711; - ans = 64'h75E7946160589711; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4444745\n"); - end - xrf = 64'hFFF0000000080800; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'hBFE0000000000000; - ans = 64'hFFF8000000080800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4445359\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h48000003FFFFFFFE; - zrf = 64'h33DFFDFFF0000000; - ans = 64'hC8000003FFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4445973\n"); - end - xrf = 64'h3C8FFFFFFFFFF007; - y = 64'hBFE0000000000001; - zrf = 64'hBFB361DCE00A17AE; - ans = 64'hBFB361DCE00A17B0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4446587\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hC000000000000060; - zrf = 64'h0000000000000000; - ans = 64'h400000000000005F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4447201\n"); - end - xrf = 64'hC1B0000007FFFF7F; - y = 64'h2FE62E2124D734CD; - zrf = 64'h41D44171458393A2; - ans = 64'h41D44171458393A2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4447815\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h8010000000000000; - ans = 64'h3FEFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4448429\n"); - end - xrf = 64'h3FF000020000003F; - y = 64'h6BC200FFFFFFFFFF; - zrf = 64'h4010000000000001; - ans = 64'h6BC2010240200046; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4449043\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hBFF0000000000001; - zrf = 64'h3CAFFFBFFFFFC000; + z = 64'h3FF0000000000001; ans = 64'h3FF0000000000001; rn = 1; rz = 0; @@ -340620,19 +101811,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -340648,12 +101839,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4449657\n"); + $fwrite(fp,"4362323\n"); end - xrf = 64'hC3EFFFBFFFFFBFFF; - y = 64'hC03000013FFFFFFF; - zrf = 64'hC02087F8DD9CE01A; - ans = 64'h442FFFC27FFABFFD; + x = 64'hBFF0000000010040; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hBCFDCB9919AF4A76; + ans = 64'hBCFDCB9919AF4A76; rn = 1; rz = 0; rm = 0; @@ -340667,19 +101858,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -340695,12 +101886,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4450271\n"); + $fwrite(fp,"4364337\n"); end - xrf = 64'h002FFFFFFFF7EFFF; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'hBFD0000000000001; - ans = 64'hBFD0000000000001; + x = 64'hC02000003FFFFFEF; + y = 64'hB8100001FFFFFFEE; + z = 64'hBFFB3C96CC3112C5; + ans = 64'hBFFB3C96CC3112C5; rn = 1; rz = 0; rm = 0; @@ -340714,19 +101905,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -340742,4712 +101933,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4450885\n"); + $fwrite(fp,"4366351\n"); end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hBF2FFFFF1FFFFFFF; - zrf = 64'hC29F5520930B8387; - ans = 64'hC29F5520930B8387; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4451499\n"); - end - xrf = 64'h421FFFFFFFFFFC20; - y = 64'hC000000000000000; - zrf = 64'h43E0000080000000; - ans = 64'h43E000007E000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4452113\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h401FFFE00000000F; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4452727\n"); - end - xrf = 64'hBFFFFFFFDFFFFFE0; - y = 64'hB4DF9F766CFDEA0E; - zrf = 64'hC7E0000000000403; - ans = 64'hC7E0000000000403; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4453341\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h8000000000000001; - ans = 64'h400FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4453955\n"); - end - xrf = 64'hBCF0021FFFFFFFFF; - y = 64'hB7EFC00000200000; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h400FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4454569\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hC010000000000000; - zrf = 64'h37E0040000020000; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4455183\n"); - end - xrf = 64'h37F2B538A60A0515; - y = 64'h3D40003DFFFFFFFE; - zrf = 64'hF53FFFFFE00FFFFF; - ans = 64'hF53FFFFFE00FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4455797\n"); - end - xrf = 64'h3FF0000003FFF800; - y = 64'hC010000000000001; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC010000003FFF801; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4456411\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h7FD001FFFFFFFFFB; - zrf = 64'hA63007DFFFFFFFFF; - ans = 64'hFFD001FFFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4457025\n"); - end - xrf = 64'hC3E5EA0CEE6FF1AD; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hBFE02000000007FF; - ans = 64'h4415EA0CEE6FF1AC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4457639\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hBD8000001FFFFFF7; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4458253\n"); - end - xrf = 64'hA65831A9180EEB60; - y = 64'hBFCFFFFE0001FFFF; - zrf = 64'h400CC77323CD27BE; - ans = 64'h400CC77323CD27BE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4458867\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hC340000000000001; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4459481\n"); - end - xrf = 64'h3FC367754DCF4364; - y = 64'h40609962425D9E89; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h40362179C9B21B6C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4460095\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h3AE29B265DEAD3B4; - ans = 64'h434FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4460709\n"); - end - xrf = 64'hBFF6F1BC5DB6450F; - y = 64'h381E0F99B726BB5B; - zrf = 64'h3FAE5DEFF9EC73CC; - ans = 64'h3FAE5DEFF9EC73CC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4461323\n"); - end - xrf = 64'hC16FFE01FFFFFFFF; - y = 64'hFFE0000000000000; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4461937\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h00100000007FFFFB; - zrf = 64'h40FBFFFFC0000000; - ans = 64'h40FBFFFFC0000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4462551\n"); - end - xrf = 64'hFFD00000000007E0; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h5FAC000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4463165\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'h3F04000000000FFF; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4463779\n"); - end - xrf = 64'hD5AFFF0000003FFF; - y = 64'hBFA0400000000800; - zrf = 64'h41DF800008000000; - ans = 64'h55603F7E0000287F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4464393\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hFFF0000000000000; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4465007\n"); - end - xrf = 64'hC110800000000004; - y = 64'hC7E0B558A2E301EA; - zrf = 64'h3FF0000000000000; - ans = 64'h49013B0367FA19FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4465621\n"); - end - xrf = 64'hBFEFFFFFFFFFFFFE; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h6BDA6766A28CCCC2; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4466235\n"); - end - xrf = 64'h3FEE48C9D4224B71; - y = 64'h429FDFFFFFFFFFFE; - zrf = 64'hBF60000000000040; - ans = 64'h429E2A810A4E2922; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4466849\n"); - end - xrf = 64'h3CABFFFDFFFFFFFF; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h8010000000000000; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4467463\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'hBFCFFFFFFBFFFFF0; - zrf = 64'h8C9B6947F8C21AFA; - ans = 64'h3FCFFFFFFBFFFFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4468077\n"); - end - xrf = 64'hC1A007FFFFFC0000; - y = 64'h0000000000000001; - zrf = 64'h431FFF8200000000; - ans = 64'h431FFF8200000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4468691\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h3FF54B1F5B0B9DC8; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4469305\n"); - end - xrf = 64'h3AEFFFFFFFFC0100; - y = 64'h2B5CEC374D919B1F; - zrf = 64'hC06C94846D11CB35; - ans = 64'hC06C94846D11CB35; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4469919\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4470533\n"); - end - xrf = 64'h34A08D3D62999585; - y = 64'h8010000000080400; - zrf = 64'h3FE0000000000001; - ans = 64'h3FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4471147\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h0010000000000000; - zrf = 64'h41C000003FFFFBFF; - ans = 64'h41C000003FFFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4471761\n"); - end - xrf = 64'h3FD2E7DC2D169C07; - y = 64'h3E0FFFFFFFFFFB00; - zrf = 64'hBFF00000007FFF7F; - ans = 64'hBFF00000006D17A3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4472375\n"); - end - xrf = 64'h3893FFFFFFFFFFF7; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h8000000000000001; - ans = 64'h8000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4472989\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h41D7FFFFFFFF7FFF; - zrf = 64'hC02FFDFFFFFFFFF7; - ans = 64'hC1D8000003FF3FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4473603\n"); - end - xrf = 64'hC0106D5AD568FA9B; - y = 64'h3CA0000000000000; - zrf = 64'h4030000007FFFFEF; - ans = 64'h4030000007FFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4474217\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h40100003FFFFFFFD; - zrf = 64'hC010000000000001; - ans = 64'hC0200001FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4474831\n"); - end - xrf = 64'h402FFFE7FFFFFFFF; - y = 64'h8000100010000000; - zrf = 64'hC02FFFFFF80003FE; - ans = 64'hC02FFFFFF80003FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4475445\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4476059\n"); - end - xrf = 64'h41ED4E128663BF92; - y = 64'hC0069229A4A92668; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'hC204AB8713B87D6D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4476673\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h7FEFFFE001FFFFFF; - ans = 64'h7FEFFFE001FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4477287\n"); - end - xrf = 64'hC3FFFFFE00000007; - y = 64'h41EF80000000001F; - zrf = 64'hC3D00000001FFFFA; - ans = 64'hC5FF7FFE08040026; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4477901\n"); - end - xrf = 64'h802FFFFFFFFFFBFD; - y = 64'h3FD0000000000001; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4478515\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h38FFFFBFFE000000; - zrf = 64'hC06C000000000200; - ans = 64'hC06C000000000200; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4479129\n"); - end - xrf = 64'h403FFFFFFFFFFFEF; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'hC7F1000000000000; - ans = 64'hC7F1000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4479743\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h47EDE7848CD1BB79; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC7EDE7848CD1BB79; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4480357\n"); - end - xrf = 64'h406FC00003FFFFFF; - y = 64'hBFEFFFFFFFFF80FF; - zrf = 64'h801FFFE00003FFFF; - ans = 64'hC06FC00003FF81FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4480971\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h3FE0000000000001; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h401DFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4481585\n"); - end - xrf = 64'h053E732B4B411CB3; - y = 64'hBFBC9367DE2B2A29; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h3CAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4482199\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'hFFDFFFFFFFF7FFBF; - ans = 64'hFFDFFFFFFFF7FFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4482813\n"); - end - xrf = 64'h402FFFFFFFFFFFFF; - y = 64'hBF3FFFFFFF7FFBFF; - zrf = 64'hB7E926CB1EEB095D; - ans = 64'hBF7FFFFFFF7FFBFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4483427\n"); - end - xrf = 64'hBFF000001FFFFFF6; - y = 64'h3FF0000000000000; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4484041\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h3E54FD33070ADB50; - zrf = 64'h0D70080040000000; - ans = 64'hBE54FD33070ADB50; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4484655\n"); - end - xrf = 64'h3F3FFFFCFFFFFFFE; - y = 64'h3FF0000000000001; - zrf = 64'h4131B98A65EEB8C2; - ans = 64'h4131B98A660EB8BF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4485269\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h70433AD0DB94E659; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hF0433AD0DB94E659; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4485883\n"); - end - xrf = 64'h37EFFBEFFFFFFFFE; - y = 64'hBFF000007FFFBFFF; - zrf = 64'h7FD037185BD9227A; - ans = 64'h7FD037185BD9227A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4486497\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h4000000000000000; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h3FFFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4487111\n"); - end - xrf = 64'h43E00000003DFFFF; - y = 64'hC380000004001FFF; - zrf = 64'h3CA0000000000000; - ans = 64'hC7700000043E1FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4487725\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h4000000000000001; - zrf = 64'h47EFFFE000100000; - ans = 64'h47EFFFE000100000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4488339\n"); - end - xrf = 64'hBFEF591F142E65F4; - y = 64'h7FD0000000004004; - zrf = 64'hFFEFFFFFFFFFFEFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4488953\n"); - end - xrf = 64'h4120000000000000; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4489567\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'hBC60007FFFFFFFFF; - zrf = 64'hBFFB251494D87C1C; - ans = 64'hBFFB251494D87C1C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4490181\n"); - end - xrf = 64'hBF9000001FFFFFDF; - y = 64'h4010000000000000; - zrf = 64'h380FFFFFFFFF3FFF; - ans = 64'hBFB000001FFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4490795\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'hB8091014356045EE; - zrf = 64'hBFF0000000000000; - ans = 64'hBFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4491409\n"); - end - xrf = 64'hC18000007FFFFFFD; - y = 64'hBFBFFFFFFFFF8FFF; - zrf = 64'h468FFF9FFFFFFFFF; - ans = 64'h468FFF9FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4492023\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h4000000000000000; - ans = 64'hC017FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4492637\n"); - end - xrf = 64'hC0DFFFFFFF0FFFFF; - y = 64'h3E2F8000000FFFFF; - zrf = 64'h0010000000000001; - ans = 64'hBF1F7FFFFF23BFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4493251\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h4340000000000000; - zrf = 64'hC3EC2A9CD7114506; - ans = 64'hC3EC2E9CD7114506; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4493865\n"); - end - xrf = 64'h43C47653FECC578C; - y = 64'hC1D000001FE00000; - zrf = 64'h40200077FFFFFFFE; - ans = 64'hC5A47654279012E2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4494479\n"); - end - xrf = 64'h30C4C31B6A0656BD; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4495093\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'hC2EFFFFFFBFF7FFF; - zrf = 64'h403FFFFF000007FF; - ans = 64'h42EFFFFFFBFF83FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4495707\n"); - end - xrf = 64'hC27582E909DF3864; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h480FFDFFFFFFFBFF; - ans = 64'h480FFDFFFFFD4BA2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4496321\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'hC3CFFFFFFBFFFFFF; - zrf = 64'hBFE0000000000001; - ans = 64'h43CFFFFFFBFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4496935\n"); - end - xrf = 64'hC012992CEE7EA6E1; - y = 64'hC4D0010000007FFE; - zrf = 64'hC1CFFFFBFFFEFFFF; - ans = 64'h44F29A56814E238F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4497549\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h3FF0000000000001; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4498163\n"); - end - xrf = 64'hBF4FBFFFFF800000; - y = 64'hC3D0000004020000; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h432FC0000773F800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4498777\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hC050635E78DEC6FE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4499391\n"); - end - xrf = 64'h3B8FFFFFDFFFFFF8; - y = 64'hC074000000000007; - zrf = 64'h4D8FFFFFFDFFFF7E; - ans = 64'h4D8FFFFFFDFFFF7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4500005\n"); - end - xrf = 64'hC1D00000080003FF; - y = 64'h7FF0000000000001; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4500619\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'hB535446544ED6F3B; - zrf = 64'h47EFFFFFFDFFFFDE; - ans = 64'h47EFFFFFFDFFFFDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4501233\n"); - end - xrf = 64'h4CF08000000007FF; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h47F02000000001FF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4501847\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'hBF903BFFFFFFFFFF; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFDEFC3FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4502461\n"); - end - xrf = 64'hC14BFFFE00000000; - y = 64'hC1CC2425E6224EA1; - zrf = 64'hC3400007FFDFFFFF; - ans = 64'hC333B0404C322CC9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4503075\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h8000000000000001; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4503689\n"); - end - xrf = 64'h338FFDFFFFFFFEFF; - y = 64'h3F6FFFFFFFFFE7FF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4504303\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hB81734522DA7FB3B; - ans = 64'hB81734522DA7FB3B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4504917\n"); - end - xrf = 64'hC038FA164937D844; - y = 64'h4020000100000007; - zrf = 64'hC80FFF8007FFFFFF; - ans = 64'hC80FFF8007FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4505531\n"); - end - xrf = 64'h43E18FC981DF1782; - y = 64'h8010000000000000; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4506145\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h37FFFFFFFFFFFFFE; - zrf = 64'hBF6FFFFFE000001F; - ans = 64'hBF6FFFFFE000001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4506759\n"); - end - xrf = 64'h40DFFFFBFFFFFFBE; - y = 64'h8010000000000001; - zrf = 64'h5941AA79E254FE7C; - ans = 64'h5941AA79E254FE7C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4507373\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'hFFEFFFFDBFFFFFFF; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'h7FEFFFFDBFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4507987\n"); - end - xrf = 64'hC010000EFFFFFFFF; - y = 64'h061D9118C37B428E; - zrf = 64'h4074B20270A76B8B; - ans = 64'h4074B20270A76B8B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4508601\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'hBCA0000000000000; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4509215\n"); - end - xrf = 64'h406000002FFFFFFF; - y = 64'h474FFFF800000FFF; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4509829\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'hBCA0000000000001; - zrf = 64'h40625A42A83240DD; - ans = 64'h40625A42A83240DD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4510443\n"); - end - xrf = 64'hBCAE7E32F882E145; - y = 64'h41F4A91FD5745E99; - zrf = 64'h4082103E0B0EEBF5; - ans = 64'h4082103E0A716BB0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4511057\n"); - end - xrf = 64'h47EFFDFFFFFEFFFF; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h4000000000000000; - ans = 64'hC4AFFDFFFFFEFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4511671\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h7FEE79620D6305DE; - zrf = 64'hC020000000000807; - ans = 64'hFFEE79620D6305DE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4512285\n"); - end - xrf = 64'hC0111FFFFFFFFFFF; + x = 64'hBFEFFFFFFFFFFFFF; y = 64'hBFD0000000000000; - zrf = 64'hFFE100007FFFFFFE; - ans = 64'hFFE100007FFFFFFE; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; rn = 1; rz = 0; rm = 0; @@ -345461,19 +101952,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -345489,106 +101980,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4512899\n"); + $fwrite(fp,"4368365\n"); end - xrf = 64'hBFF0000000000000; - y = 64'h3F3000040000003E; - zrf = 64'hBCA0000000000000; - ans = 64'hBF3000040000083E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4513513\n"); - end - xrf = 64'h5ACFFFF80000007F; - y = 64'h4E9FF000001FFFFF; - zrf = 64'h43D009ABAC9520F9; - ans = 64'h697FEFF804200076; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4514127\n"); - end - xrf = 64'hBFF0000000000000; + x = 64'hBCA0000000100001; y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h3FD0000000000000; - ans = 64'h3FE7FFFFFFFFFFFF; + z = 64'hCDD09F02D825FADA; + ans = 64'hCDD09F02D825FADA; rn = 1; rz = 0; rm = 0; @@ -345602,19 +101999,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -345630,12 +102027,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4514741\n"); + $fwrite(fp,"4370379\n"); end - xrf = 64'hC7ECD7DD2E3D95E4; - y = 64'h47CF00000001FFFF; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; + x = 64'h860004000000003E; + y = 64'h402FFFFFFFFF7FFF; + z = 64'h37F0B37850D0BDF3; + ans = 64'h37F0B37850D0BDF3; rn = 1; rz = 0; rm = 0; @@ -345649,19 +102046,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -345677,1092 +102074,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4515355\n"); + $fwrite(fp,"4372393\n"); end - xrf = 64'hBFF0000000000000; - y = 64'hBFE0000000000000; - zrf = 64'h2F5FFFFFFD000000; - ans = 64'h3FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4515969\n"); - end - xrf = 64'h291FFFEFFFFFF7FF; - y = 64'hFFF000000004001F; - zrf = 64'hBB6320FE2C69FFB9; - ans = 64'hFFF800000004001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4516583\n"); - end - xrf = 64'h41B000040000001E; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h3FF0000000000001; - ans = 64'hC1B00003FF00001D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4517197\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h41C07FFDFFFFFFFF; - zrf = 64'h43FFBFFFFFFFFFFC; - ans = 64'h43FFBFFFFFFDEFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4517811\n"); - end - xrf = 64'hD04FFFFFFEFDFFFF; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h401271732DE85299; - ans = 64'h504FFFFFFEFDFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4518425\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'hBFE0FFFFFFFFFFFF; - zrf = 64'h8010000000000001; - ans = 64'h3FE0FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4519039\n"); - end - xrf = 64'hC01FFFFFFE0003FF; - y = 64'h802000000FBFFFFF; - zrf = 64'hC7F36140930E40F9; - ans = 64'hC7F36140930E40F9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4519653\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h3CA0000000000001; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4520267\n"); - end - xrf = 64'h402FFF7FFFFF8000; - y = 64'h4392F5D9CE42A48A; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'h43D2E58DF6DB1FA8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4520881\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hBFF00020007FFFFE; - ans = 64'h3FEFFFBFFF000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4521495\n"); - end - xrf = 64'hBFC0EF47C9D14FDF; - y = 64'h407FEDE822B7EAF3; - zrf = 64'hAD6FFFE001FFFFFE; - ans = 64'hC050E5B4905983C4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4522109\n"); - end - xrf = 64'hFFE3FC0000000000; - y = 64'hC000000000000001; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4522723\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h40200000000000E0; - zrf = 64'h7850010400000000; - ans = 64'h7850010400000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4523337\n"); - end - xrf = 64'hC0C74001808B0561; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'hFA8DFFFFBFFFFFFF; - ans = 64'hFA8DFFFFBFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4523951\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'hBFEB4F958D0F7BC7; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h3FEB4F958D0F7BC7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4524565\n"); - end - xrf = 64'hD0B03FFFFC000000; - y = 64'h3800000000000005; - zrf = 64'h3FCFFFFFE4000000; - ans = 64'hC8C03FFFFC000005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4525179\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'hC010000000000001; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h4010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4525793\n"); - end - xrf = 64'h3F9CAA634D14DAC3; - y = 64'hC3EFFFFFFFFFC03F; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC39CAA634D14A1A7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4526407\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h3800000000017FFE; - ans = 64'h401FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4527021\n"); - end - xrf = 64'h402000000000083E; - y = 64'hFFFD1692B75F4C6C; - zrf = 64'hC0AFFFFFFFE10000; - ans = 64'hFFFD1692B75F4C6C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4527635\n"); - end - xrf = 64'hA92D46FFAC47C8A3; - y = 64'hC340000000000000; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4528249\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h7FE000000000BFFF; - zrf = 64'hBCA0FFFFFC000000; - ans = 64'hFFE000000000BFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4528863\n"); - end - xrf = 64'hBE1FFFE000000400; - y = 64'hC340000000000001; - zrf = 64'hFB92CC5313B02F3E; - ans = 64'hFB92CC5313B02F3E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4529477\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'h3FBA1095BDD6787C; - zrf = 64'h7FFFFFFFFFFFFFFE; + x = 64'hBFEFFFFFFFFFFFFF; + y = 64'hBFF0000000000000; + z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -346777,19 +102093,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -346805,12 +102121,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4530091\n"); + $fwrite(fp,"4374407\n"); end - xrf = 64'h42E00000000001FC; - y = 64'hC35FFFFE10000000; - zrf = 64'hBAE0010000040000; - ans = 64'hC64FFFFE100003F8; + x = 64'hC3C0003FFFFFFFDE; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h3EA0FFFFDFFFFFFF; + ans = 64'h43D0003FFFFFFFDD; rn = 1; rz = 0; rm = 0; @@ -346824,19 +102140,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -346852,12 +102168,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4530705\n"); + $fwrite(fp,"4376421\n"); end - xrf = 64'hBFF0000000000000; - y = 64'hFFE0000000000000; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h7FE0000000000000; + x = 64'hBFB00FFFFEFFFFFE; + y = 64'h7FDFFFFFFFFFBFFF; + z = 64'h2BFBE93A66C88A23; + ans = 64'hFFA00FFFFEFFDFDD; rn = 1; rz = 0; rm = 0; @@ -346871,19 +102187,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -346899,12 +102215,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4531319\n"); + $fwrite(fp,"4378435\n"); end - xrf = 64'hC3EFFFFFEFF7FFFE; - y = 64'hAE9FFFFFFFDFFFFF; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; + x = 64'hBFEFFFFFFFFFFFFF; + y = 64'hC010000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h400FFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -346918,19 +102234,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -346946,12 +102262,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4531933\n"); + $fwrite(fp,"4380449\n"); end - xrf = 64'hBFF0000000000000; - y = 64'hFFE0000000000001; - zrf = 64'hBEFFFFFFFFF80800; - ans = 64'h7FE0000000000001; + x = 64'hC14FFFFFFFFF7DFF; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hFFEFFFFFFBFFFE00; + ans = 64'hFFEFFFFFFBFFFE00; rn = 1; rz = 0; rm = 0; @@ -346965,19 +102281,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -346993,12 +102309,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4532547\n"); + $fwrite(fp,"4382463\n"); end - xrf = 64'h4016000000000000; - y = 64'hC02FFFFFF0000002; - zrf = 64'hC3DFFFFFFF800020; - ans = 64'hC3DFFFFFFF800020; + x = 64'h52CFFFFFFFBFFF7F; + y = 64'h30BFFFFBFFFE0000; + z = 64'hBE5FFFF7FFFFFBFE; + ans = 64'h439FFFFBFFBDFF87; rn = 1; rz = 0; rm = 0; @@ -347012,19 +102328,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -347040,12 +102356,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4533161\n"); + $fwrite(fp,"4384477\n"); end - xrf = 64'hC0E0000FFFFE0000; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h3FD0000000000000; - ans = 64'h7FF0000000000000; + x = 64'hBFEFFFFFFFFFFFFF; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'h434FFFFFFFFFFFFD; rn = 1; rz = 0; rm = 0; @@ -347059,19 +102375,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -347087,12 +102403,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4533775\n"); + $fwrite(fp,"4386491\n"); end - xrf = 64'hBFF0000000000000; - y = 64'h3800000000FFEFFF; - zrf = 64'hC1C00001FFFFFFEF; - ans = 64'hC1C00001FFFFFFEF; + x = 64'h41EFFFFFDFFFFF7F; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hBFBFFBFFFFFDFFFF; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -347106,19 +102422,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -347134,12 +102450,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4534389\n"); + $fwrite(fp,"4388505\n"); end - xrf = 64'hC010000100100000; - y = 64'hFFF0000000000000; - zrf = 64'hBD85C262E3D194AB; - ans = 64'h7FF0000000000000; + x = 64'hC1E1FFFFFFFFFFFE; + y = 64'h43C400000001FFFF; + z = 64'hBFC1007FFFFFFFFF; + ans = 64'hC5B6800000023FFC; rn = 1; rz = 0; rm = 0; @@ -347153,19 +102469,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -347181,105 +102497,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4535003\n"); + $fwrite(fp,"4390519\n"); end - xrf = 64'hBFF0000000000000; - y = 64'hB7FFFFFFE0000FFE; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4535617\n"); - end - xrf = 64'h3A1DFFFFFF7FFFFF; - y = 64'hC031FFFFFFFFFFFC; - zrf = 64'h0001574452FD6F0C; - ans = 64'hBA60DFFFFFB7FFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4536231\n"); - end - xrf = 64'hBFF0000000000000; + x = 64'hBFEFFFFFFFFFFFFF; y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h0000000000000000; + z = 64'h4340000000000000; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -347294,19 +102516,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -347322,12 +102544,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4536845\n"); + $fwrite(fp,"4392533\n"); end - xrf = 64'h407FFC00000007FE; - y = 64'h47F007FFFC000000; - zrf = 64'hC000000000000001; - ans = 64'h488005FEFC008401; + x = 64'h3F0C000000000000; + y = 64'h0000000000000001; + z = 64'h26D0000040000003; + ans = 64'h26D0000040000003; rn = 1; rz = 0; rm = 0; @@ -347341,19 +102563,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -347369,12 +102591,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4537459\n"); + $fwrite(fp,"4394547\n"); end - xrf = 64'hBFF0000000000001; - y = 64'h0000000000000000; - zrf = 64'h416DD2ED9FF40F71; - ans = 64'h416DD2ED9FF40F71; + x = 64'h45DFFFFFEEFFFFFF; + y = 64'h0DBFFFF900000000; + z = 64'hFFF0000000001FEE; + ans = 64'hFFF8000000001FEE; rn = 1; rz = 0; rm = 0; @@ -347388,19 +102610,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -347416,12 +102638,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4538073\n"); + $fwrite(fp,"4396561\n"); end - xrf = 64'h591FDFFFFFFFFEFF; - y = 64'hC002D7372503CD74; - zrf = 64'h47200001FFFFFF80; - ans = 64'hD932C45FEDDEC90F; + x = 64'hBFEFFFFFFFFFFFFE; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -347435,19 +102657,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -347463,435 +102685,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4538687\n"); + $fwrite(fp,"4398575\n"); end - xrf = 64'h394FFFFFEFFBFFFF; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h3CA0000000000001; - ans = 64'h3CA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4539301\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h41D0000000011FFF; - zrf = 64'h001FFFFFFFFFFF00; - ans = 64'hC1D0000000012000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4539915\n"); - end - xrf = 64'h3CA556FA6E4F563F; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hBEF00000FFFDFFFF; - ans = 64'hBEF00000FFFDFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4540529\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'hC7F000000001DFFF; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4541143\n"); - end - xrf = 64'hF86FDFFFF0000000; - y = 64'h85B000800000003E; - zrf = 64'h4010080004000000; - ans = 64'h40100800043FC1FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4541757\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h0010000000000001; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4542371\n"); - end - xrf = 64'h38099987D76195AA; - y = 64'hBF2000000005FFFE; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4542985\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h3FDFFFF800007FFF; - ans = 64'h3FDFFFF800007FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4543599\n"); - end - xrf = 64'h3FEFFFFFFFFE01FE; - y = 64'h7FDFC00004000000; - zrf = 64'h4028AD7BEFC7DBB7; - ans = 64'h7FDFC00003FE05FA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4544213\n"); - end - xrf = 64'h434FFFDFFFFFF000; + x = 64'h37F0000FFFFFF800; y = 64'h3CA0000000000001; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h3FFFFFDFFFFFF002; + z = 64'h4000100000007FFF; + ans = 64'h4000100000007FFF; rn = 1; rz = 0; rm = 0; @@ -347905,19 +102704,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -347933,12 +102732,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4544827\n"); + $fwrite(fp,"4400589\n"); end - xrf = 64'hBFF0000000000001; - y = 64'h002DEAE1FFAB18CF; - zrf = 64'hB7FCBE33FBA6921C; - ans = 64'hB7FCBE33FBA6921C; + x = 64'h8021B1B7A213FD62; + y = 64'h9BEEFFFFFEFFFFFF; + z = 64'h20DF81119141D6F5; + ans = 64'h20DF81119141D6F5; rn = 1; rz = 0; rm = 0; @@ -347952,19 +102751,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -347980,246 +102779,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4545441\n"); + $fwrite(fp,"4402603\n"); end - xrf = 64'hC1DFFFFFBFF7FFFF; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hC94FFFE00000003E; - ans = 64'hC94FFFE00000003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4546055\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'hC982CAD0B6A6CA42; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h4982CAD0B6A6CA43; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4546669\n"); - end - xrf = 64'h3630100200000000; - y = 64'hBFC41AC47AADFBDF; - zrf = 64'hFEA0040001FFFFFF; - ans = 64'hFEA0040001FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4547283\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h3FD0000000000000; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4547897\n"); - end - xrf = 64'h38065ABAD779A5CE; - y = 64'h41F004000000003F; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hBFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4548511\n"); - end - xrf = 64'hBFF0000000000001; + x = 64'hBFEFFFFFFFFFFFFE; y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h9F340000000000FE; + z = 64'hBCAFFFFFFFFFFFFF; ans = 64'hBFE0000000000000; rn = 1; rz = 0; @@ -348234,19 +102798,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -348262,153 +102826,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4549125\n"); + $fwrite(fp,"4404617\n"); end - xrf = 64'h47FE000000000003; - y = 64'h402000000F7FFFFF; - zrf = 64'h416FFFFFFE03FFFE; - ans = 64'h482E00001D100001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4549739\n"); - end - xrf = 64'h914968BAEE7BA6C3; - y = 64'h3FE0000000000000; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h913968BAEE7BA6C3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4550353\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'hC1CC67EF3F5810BA; - zrf = 64'hC3ED40AE3EE13419; - ans = 64'hC3ED40AE3EDA1A1D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4550967\n"); - end - xrf = 64'hD4D00000000004FF; + x = 64'hC02FFFFFC1000000; y = 64'h3FE0000000000001; - zrf = 64'h3E8FFFFFFEFFFFFF; - ans = 64'hD4C0000000000500; + z = 64'h0E1FFFFFFFFFFFDF; + ans = 64'hC01FFFFFC1000002; rn = 1; rz = 0; rm = 0; @@ -348422,19 +102845,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -348450,12 +102873,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4551581\n"); + $fwrite(fp,"4406631\n"); end - xrf = 64'hBFF0000000000001; - y = 64'hBFB0000FFFF7FFFF; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h402020001FFFEFFF; + x = 64'hBFE4E0F4ED990912; + y = 64'hFFE0FFFDFFFFFFFE; + z = 64'h395AD82B659403EC; + ans = 64'h7FD62F01A053FBED; rn = 1; rz = 0; rm = 0; @@ -348469,19 +102892,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -348497,12 +102920,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4552195\n"); + $fwrite(fp,"4408645\n"); end - xrf = 64'hC0000001FFFFF7FE; - y = 64'h3BFFC001FFFFFFFF; - zrf = 64'h3FAFFFFDFFFF0000; - ans = 64'h3FAFFFFDFFFF0000; + x = 64'hBFEFFFFFFFFFFFFE; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'hBFEFFFFFFFFFFFF8; rn = 1; rz = 0; rm = 0; @@ -348516,19 +102939,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -348544,294 +102967,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4552809\n"); + $fwrite(fp,"4410659\n"); end - xrf = 64'hBFF0000000000001; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4553423\n"); - end - xrf = 64'h41EFFFFFFAFFFFFE; - y = 64'hBF800000007FF800; - zrf = 64'hBFE0000000000000; - ans = 64'hC180000001FFF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4554037\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h3FF0000000000001; - zrf = 64'hBCAFFFFFFFFF6000; - ans = 64'hBFF0000000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4554651\n"); - end - xrf = 64'h3FD0000000C00000; - y = 64'hC08FFFC000000020; - zrf = 64'h3633FFFFFFFFFF00; - ans = 64'hC06FFFC0017FFD20; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4555265\n"); - end - xrf = 64'h47E0361A27E510F0; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h0000000000000000; - ans = 64'h47F0361A27E510EF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4555879\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h401A000000000000; - zrf = 64'h40E00003EFFFFFFF; - ans = 64'h40DFFE67DFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4556493\n"); - end - xrf = 64'hC3F06A2BA00B7121; + x = 64'hC1FFFFFFFFFFFFDF; y = 64'h4000000000000000; - zrf = 64'h47FFFFFE0FFFFFFF; - ans = 64'h47FFFFFE0FFFFFFF; + z = 64'h402DFFFEFFFFFFFF; + ans = 64'hC20FFFFFFF87FFE3; rn = 1; rz = 0; rm = 0; @@ -348845,19 +102986,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -348873,12 +103014,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4557107\n"); + $fwrite(fp,"4412673\n"); end - xrf = 64'hBFF0000000000001; - y = 64'h41D6D8801C07B5D9; - zrf = 64'h4010000000000000; - ans = 64'hC1D6D8801B07B5DA; + x = 64'h7F3A96D500067E61; + y = 64'hBFBFFFFBDFFFFFFF; + z = 64'hC030080000000007; + ans = 64'hFF0A96D19295095F; rn = 1; rz = 0; rm = 0; @@ -348892,19 +103033,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -348920,58 +103061,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4557721\n"); + $fwrite(fp,"4414687\n"); end - xrf = 64'hC008653E2BFF5278; - y = 64'hC7F000000080000F; - zrf = 64'h37F0000000000104; - ans = 64'h4808653E2CC27C80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4558335\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hC340000000000000; + x = 64'hBFEFFFFFFFFFFFFE; + y = 64'h4010000000000001; + z = 64'hC340000000000000; ans = 64'hC340000000000002; rn = 1; rz = 0; @@ -348986,19 +103080,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -349014,5652 +103108,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4558949\n"); + $fwrite(fp,"4416701\n"); end - xrf = 64'h43000003FFFFFFDF; - y = 64'h000FFFDFFFBFFFFF; - zrf = 64'hBFD0000000000001; - ans = 64'hBFD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4559563\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h4010000000000000; - zrf = 64'h3F400077FFFFFFFF; - ans = 64'hC00FFEFFF8800002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4560177\n"); - end - xrf = 64'h40000000003FFEFE; - y = 64'hB80956189D5C0BE5; - zrf = 64'hFFE00000003FC000; - ans = 64'hFFE00000003FC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4560791\n"); - end - xrf = 64'hFFE0080080000000; - y = 64'h4010000000000001; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4561405\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h3F1FFFF000007FFF; - zrf = 64'hBFC200000000003F; - ans = 64'hBFC203FFFE00004F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4562019\n"); - end - xrf = 64'h37F8000000000000; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hBFBFFFFFFFFFE007; - ans = 64'hBFBFFFFFFFFFE007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4562633\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h3FD0FFFFFFF00000; - zrf = 64'h4000000000000001; - ans = 64'h3FFBC00000040002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4563247\n"); - end - xrf = 64'hC1F5F34E329FC529; - y = 64'hCABFFFF7FFFFFFF6; - zrf = 64'h3FC000000007FFFC; - ans = 64'h4CC5F348B5CC387A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4563861\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h4340000000000001; - zrf = 64'hC010000000000001; - ans = 64'hC340000000000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4564475\n"); - end - xrf = 64'hCB60008000000008; - y = 64'hC31C0C3C49302829; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h4E8C0D1CAB1271B8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4565089\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hC01FFFFFFFFFF7FD; - ans = 64'hC350000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4565703\n"); - end - xrf = 64'h3D20000004000020; - y = 64'h37EFFFE000000400; - zrf = 64'hBFD63728002F7F26; - ans = 64'hBFD63728002F7F26; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4566317\n"); - end - xrf = 64'h421FFFF600000000; - y = 64'h7FE0000000000000; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4566931\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h37F00400000FFFFE; - zrf = 64'h7FFBFF65F9F97192; - ans = 64'h7FFBFF65F9F97192; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4567545\n"); - end - xrf = 64'hBFED1E2D349F9634; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h41EE47EAA0C8C79B; - ans = 64'hFFED1E2D349F9633; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4568159\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h5D9007FFFFFFFBFE; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'hDD9007FFFFFFFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4568773\n"); - end - xrf = 64'hBFF01FFF7FFFFFFF; - y = 64'hBF40080000000200; - zrf = 64'hBFAE4EAF768B004A; - ans = 64'hBFAE0E0F388C0042; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4569387\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h7FF0000000000000; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4570001\n"); - end - xrf = 64'h3FEB53EC4ED42246; - y = 64'h200FF00000FFFFFE; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h200B464259875796; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4570615\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h06DFFFFFFFFF0100; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4571229\n"); - end - xrf = 64'hC2CFF00000000200; - y = 64'h3CACD1481562CF5A; - zrf = 64'hC1C2B76274D1B41A; - ans = 64'hC1C2B76274D38048; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4571843\n"); - end - xrf = 64'hBC00000013FFFFFF; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4572457\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'hC3C00000001FFFFC; - zrf = 64'h7FEFEFFFFFFFFDFE; - ans = 64'h7FEFEFFFFFFFFDFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4573071\n"); - end - xrf = 64'hBFCFDFFFFEFFFFFF; - y = 64'h8000000000000001; - zrf = 64'h000FFFFFFFFFE080; - ans = 64'h000FFFFFFFFFE080; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4573685\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h380FDFFE00000000; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h3FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4574299\n"); - end - xrf = 64'h41DFFFFFFFFFF77F; - y = 64'hD453FFFFFFEFFFFF; - zrf = 64'hC00000800007FFFF; - ans = 64'hD643FFFFFFEFFAAE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4574913\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hBFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4575527\n"); - end - xrf = 64'h8022000000000040; - y = 64'h7FFFFFFFFF7FFFFB; - zrf = 64'h8010000000000000; - ans = 64'h7FFFFFFFFF7FFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4576141\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h8010000000000001; - zrf = 64'hC1DFFFFFFDFFFFBF; - ans = 64'hC1DFFFFFFDFFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4576755\n"); - end - xrf = 64'hC0300000000003BF; - y = 64'h4350080003FFFFFF; - zrf = 64'hC09000040003FFFF; - ans = 64'hC3900800040003D0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4577369\n"); - end - xrf = 64'h40341EADFA6475B2; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4577983\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h3FAFFFFFFFFFFFF9; - zrf = 64'h4000FFFFFFFFF000; - ans = 64'h40007FFFFFFFF000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4578597\n"); - end - xrf = 64'h43CFFFFFFFFF7FFF; - y = 64'hBCA0000000000000; - zrf = 64'h8BC000000003FFBE; - ans = 64'hC07FFFFFFFFF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4579211\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h43E380CC2973ACB3; - zrf = 64'h3FE0000000000000; - ans = 64'hC3E380CC2973ACB4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4579825\n"); - end - xrf = 64'h41F003FFFE000000; - y = 64'hBC6000000000000C; - zrf = 64'hBCAFFFFF803FFFFF; - ans = 64'hBE60040000000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4580439\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'hBFF0000000000000; - ans = 64'hBFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4581053\n"); - end - xrf = 64'h47E001FFFFFFFFFF; - y = 64'h43F100000000000F; - zrf = 64'h8000000000000001; - ans = 64'h4BE102200000000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4581667\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'hBFD0000000000000; - zrf = 64'hE2F7757C81753CD8; - ans = 64'hE2F7757C81753CD8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4582281\n"); - end - xrf = 64'h37F39A26220B80B2; - y = 64'hC02B909F89E563F8; - zrf = 64'hB89FFFFFFFFEFFBF; - ans = 64'hB8A021C54F24F192; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4582895\n"); - end - xrf = 64'h3F8FFFFFFFFFEFFD; - y = 64'hBFD0000000000001; - zrf = 64'hC010000000000001; - ans = 64'hC01003FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4583509\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h800007FFFFFFFF00; - zrf = 64'hBFBFFFFFFFFFFFFF; - ans = 64'hBFBFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4584123\n"); - end - xrf = 64'hD90000000000000F; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h380FFFFFFFFFFF00; - ans = 64'h58F000000000000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4584737\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h4031000000000020; - zrf = 64'h3FD0000000000001; - ans = 64'hC030C00000000021; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4585351\n"); - end - xrf = 64'hC3CFFFFFFC00000E; - y = 64'h1D11BFFFFFFFFFFE; - zrf = 64'h47FFFFFFF000000E; - ans = 64'h47FFFFFFF000000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4585965\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'hBFE0000000000001; - zrf = 64'hBFE0000000000001; - ans = 64'h3CA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4586579\n"); - end - xrf = 64'h718FF800000007FF; - y = 64'h402C00007FFFFFFE; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4587193\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hBFBF7FFFFFDFFFFF; - ans = 64'h3FEC100000040000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4587807\n"); - end - xrf = 64'h4001FFFFFFFFBFFF; - y = 64'hC05000000400000E; - zrf = 64'h40B000000007E000; - ans = 64'h40AEDFFFFFC7C3FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4588421\n"); - end - xrf = 64'hC03CE12C88B4CE88; - y = 64'hBFF0000000000000; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'h4038E12C88B4CE88; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4589035\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'hC79F8CB9350D70FE; - zrf = 64'h400FFFFFFFFDFFFE; - ans = 64'h479F8CB9350D7100; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4589649\n"); - end - xrf = 64'hB7F0007FFFFFFDFF; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h40BFFFFFFFFFE1FF; - ans = 64'h40BFFFFFFFFFE1FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4590263\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'hBAA3255E5E8B552D; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CB00000000992AF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4590877\n"); - end - xrf = 64'h1AA19F0D4BA05A96; - y = 64'hC0CC1EA8C3F96032; - zrf = 64'hC03C3ADC439DF04B; - ans = 64'hC03C3ADC439DF04B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4591491\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'hC000000000000000; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'h3FF8000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4592105\n"); - end - xrf = 64'h41EFFCFFFFFFFFFE; - y = 64'hC8000000040001FF; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4592719\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'hBF4E6186BCBE18C6; - ans = 64'h400FFE19E794341F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4593333\n"); - end - xrf = 64'hC00FFE00003FFFFE; - y = 64'hBFFFFFFFFFEFFFFF; - zrf = 64'h41C3E00000000000; - ans = 64'h41C3E00003FFC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4593947\n"); - end - xrf = 64'hE118000010000000; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'h613800000FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4594561\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h4000000000080400; - zrf = 64'hFFEE00000000003E; - ans = 64'hFFEE00000000003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4595175\n"); - end - xrf = 64'h4330000140000000; - y = 64'hC010000000000001; - zrf = 64'h3F500000FFFF7FFF; - ans = 64'hC350000140000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4595789\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h802FFFFFFFF7FF7E; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h0037FFFFFFFBFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4596403\n"); - end - xrf = 64'hB7EFFFFFFFF8003F; - y = 64'hC00FFFFFBFFBFFFE; - zrf = 64'h40307FFFFF7FFFFF; - ans = 64'h40307FFFFF7FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4597017\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'h4020000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4597631\n"); - end - xrf = 64'hC7FFFFFFFEFFFFFE; - y = 64'h3FBF20A58581BBC5; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4598245\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'hC340000000000001; - zrf = 64'h43F000000000000B; - ans = 64'h43F002000000000B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4598859\n"); - end - xrf = 64'h802003FFFDFFFFFE; - y = 64'hFFE000002003FFFE; - zrf = 64'hC1E0FF0000000000; - ans = 64'hC1E0FEFFFF7FDFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4599473\n"); - end - xrf = 64'h86EFFFFFFFFE0002; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hBFF0000000000000; - ans = 64'hBFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4600087\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'hFFF0000008040000; - zrf = 64'h447A0CCD5A3A45D6; - ans = 64'hFFF8000008040000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4600701\n"); - end - xrf = 64'hCF30000FF7FFFFFE; - y = 64'hFFE0000000000000; - zrf = 64'hC013000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4601315\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h37F0FFFFC0000000; - zrf = 64'h0010000000000000; - ans = 64'hB7F0FFFFC0000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4601929\n"); - end - xrf = 64'h403F7BFFFFFFFFFF; - y = 64'h5BF000000040000F; - zrf = 64'h407FFFFFFFE7FFFF; - ans = 64'h5C3F7C00007DF01D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4602543\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hBCA0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4603157\n"); - end - xrf = 64'h43F00000000FEFFF; - y = 64'h4B1E00000000007E; - zrf = 64'h4340000000000001; - ans = 64'h4F1E0000001DE27C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4603771\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'hFFF0000000000000; - zrf = 64'hB80FFDFFDFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4604385\n"); - end - xrf = 64'hC5DE1D2984F7E885; - y = 64'hBB70000000010000; - zrf = 64'hC03000000010000E; - ans = 64'h415E1D2584F9CA54; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4604999\n"); - end - xrf = 64'hD320E62A268419A5; - y = 64'hFFF0000000000001; - zrf = 64'hBFE0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4605613\n"); - end - xrf = 64'hBFF0000000000001; - y = 64'h480FFFFFFF003FFF; - zrf = 64'hC3F793A317F2E6EE; - ans = 64'hC80FFFFFFF004001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4606227\n"); - end - xrf = 64'hC1C0000001FFFFF7; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h0D381DA8EAF11F86; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4606841\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h3F7B6B3182EF4EE4; - zrf = 64'h0000000000000001; - ans = 64'hBF8B6B3182EF4EE3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4607455\n"); - end - xrf = 64'hBFF0000000000000; - y = 64'hAE10007FFFFFFC00; - zrf = 64'hC03FFFFFFFFBFC00; - ans = 64'hC03FFFFFFFFBFC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4608069\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h0000000000000001; - zrf = 64'h8010000000000001; - ans = 64'h8010000000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4608683\n"); - end - xrf = 64'h47FFFFFFF7F7FFFF; - y = 64'h43490DB3161770CB; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h4B590DB30FCDC098; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4609297\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hC3DFC000000FFFFF; - ans = 64'hC3DFC000000FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4609911\n"); - end - xrf = 64'h002FFFFFFFFFF00F; - y = 64'hBFC45845000741C5; - zrf = 64'h400FFBFFFFFFFFFF; - ans = 64'h400FFBFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4610525\n"); - end - xrf = 64'hC7F47AB1BA570432; - y = 64'h0010000000000000; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4611139\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hC020420000000000; - zrf = 64'hD8C0100000000800; - ans = 64'hD8C0100000000800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4611753\n"); - end - xrf = 64'h41DFFFFFF000000F; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h18975D7E24CBCDBC; - ans = 64'h18975D7E24CBCDBC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4612367\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h4020801FFFFFFFFF; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4612981\n"); - end - xrf = 64'h3F42E4F4DA60DA20; - y = 64'hC3EA40903E0ABD62; - zrf = 64'hC7EFFFFFFFDF7FFF; - ans = 64'hC7EFFFFFFFDF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4613595\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h3CA0000000000000; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4614209\n"); - end - xrf = 64'h3FB839B1741638F0; - y = 64'hC3D001FFFFFFFFFF; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'hC3983CB8AA44BBB6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4614823\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h3FF00000040001FF; - ans = 64'h3FF00000040001FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4615437\n"); - end - xrf = 64'h37EE0A1719392178; - y = 64'h434BB16312B10DD9; - zrf = 64'h7FEAECB2D3092E94; - ans = 64'h7FEAECB2D3092E94; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4616051\n"); - end - xrf = 64'h41CBFFFFF7FFFFFF; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'h3E8BFFFFF77FFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4616665\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h434FF0000001FFFF; - zrf = 64'hBFF00000000FDFFF; - ans = 64'hC35FF0000001FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4617279\n"); - end - xrf = 64'hC07FFFDFFFFDFFFF; - y = 64'h3FD0000000000001; - zrf = 64'h7FFE4B31330DFF8E; - ans = 64'h7FFE4B31330DFF8E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4617893\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h3FFE0000000003FF; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4618507\n"); - end - xrf = 64'hC3C000001FFFEFFF; - y = 64'h410000000200001E; - zrf = 64'h3DC0007FEFFFFFFF; - ans = 64'hC4D0000021FFF021; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4619121\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4619735\n"); - end - xrf = 64'hBFF87B5A8E0D6C01; - y = 64'h3FDFD4808363D3CB; - zrf = 64'h4000000000000000; - ans = 64'h3FF3D2F65E4329F0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4620349\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h3FE0000000000001; - zrf = 64'hC2EFFFA000000000; - ans = 64'hC2EFFFA000000020; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4620963\n"); - end - xrf = 64'hC03000FFFFFFBFFF; - y = 64'h7FE0FFFFFEFFFFFF; - zrf = 64'hBEEDCB25764FAA06; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4621577\n"); - end - xrf = 64'h3FB8F9662F0A1D3C; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'hBCA0000000000000; - ans = 64'h3FB8F9662F0A1D33; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4622191\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h7FD99F4C3169E406; - zrf = 64'h3CA2000000003FFF; - ans = 64'hFFE99F4C3169E405; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4622805\n"); - end - xrf = 64'hC01FFFFFFFFFBFBE; - y = 64'h3FF0000000000000; - zrf = 64'hFFEEE4313F716485; - ans = 64'hFFEEE4313F716485; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4623419\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h4006D472E37A54B9; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4624033\n"); - end - xrf = 64'hC01FFC0000010000; - y = 64'h402000007FBFFFFF; - zrf = 64'hC4D0000004200000; - ans = 64'hC4D0000004200000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4624647\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4625261\n"); - end - xrf = 64'hB7FFFFFFFFEFFBFF; - y = 64'h41D0004100000000; - zrf = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4625875\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h4000000000000000; - zrf = 64'hBE0FEDE2168E4AA0; - ans = 64'hC0100000000FF6F1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4626489\n"); - end - xrf = 64'hBFCFFFFFFC000006; - y = 64'h43CC000080000000; - zrf = 64'h3EFC602C2576AEC0; - ans = 64'hC3AC00007C7FFFF5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4627103\n"); - end - xrf = 64'hBFEEC902FDCB9E98; - y = 64'h4000000000000001; - zrf = 64'h8010000000000001; - ans = 64'hBFFEC902FDCB9E9A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4627717\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hB1CFFFFFFFFDFF00; - zrf = 64'h38FFFFFBBFFFFFFF; - ans = 64'h38FFFFFBBFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4628331\n"); - end - xrf = 64'hC1D7FF0000000000; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h443FFFFF7FFFFEFF; - ans = 64'h443FFFFF7FFE7F0F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4628945\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h435DDC7917576AD6; - zrf = 64'hC340000000000001; - ans = 64'hC370EE3C8BABB56B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4629559\n"); - end - xrf = 64'hBFCFFE7FFFFFFFFF; - y = 64'h3AC00000000003FF; - zrf = 64'h78B00004003FFFFE; - ans = 64'h78B00004003FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4630173\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h4010000000000001; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4630787\n"); - end - xrf = 64'hC1E0000803FFFFFF; - y = 64'hFFD9AD996E2E4039; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4631401\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hC02206B0880D60C7; - ans = 64'hC03903584406B063; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4632015\n"); - end - xrf = 64'h3F2FFFFFFF8001FF; - y = 64'h41FFFF007FFFFFFF; - zrf = 64'hC0AB85FB5533F830; - ans = 64'h413FF13D81D56C00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4632629\n"); - end - xrf = 64'hB8FFFFFFFFF7FFF7; + x = 64'hA4F00007FFFFF7FE; y = 64'h4340000000000000; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'hBC4FFFFFFFF7FFF7; + z = 64'h8A6FC00000003FFF; + ans = 64'hA8400007FFFFF7FE; rn = 1; rz = 0; rm = 0; @@ -354673,19 +103127,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -354701,12 +103155,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4633243\n"); + $fwrite(fp,"4418715\n"); end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h41C00000000005FF; - zrf = 64'h43DFFFFFFFEFFFFC; - ans = 64'h43DFFFFFFFDFFFFC; + x = 64'h40234CA759EBC6DF; + y = 64'h3FD0007FFFFFFFFB; + z = 64'hC20B30390456082E; + ans = 64'hC20B30390442BAEC; rn = 1; rz = 0; rm = 0; @@ -354720,19 +103174,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -354748,340 +103202,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4633857\n"); + $fwrite(fp,"4420729\n"); end - xrf = 64'h3BA000003FFFBFFF; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h3CAFFFFE01FFFFFF; - ans = 64'h3F00000040003FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4634471\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hBFB0000440000000; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01F7FFFDDFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4635085\n"); - end - xrf = 64'hBFDFFC0000000001; - y = 64'hC8083A4D087E2F0E; - zrf = 64'h3FEE00000000FFFF; - ans = 64'h47F83745BEDD1F49; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4635699\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h7FE0000000000000; - zrf = 64'h434FFFFFFFFFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4636313\n"); - end - xrf = 64'h43D00FFFFFFFFFF8; - y = 64'h462000FFFFFFFFFF; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h4A001100FFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4636927\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; + x = 64'hBFEFFFFFFFFFFFFE; y = 64'h7FE0000000000001; - zrf = 64'h37EF479E56DC8B9D; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4637541\n"); - end - xrf = 64'hBFB00020000001FE; - y = 64'hBFBFFFFFFBFFDFFE; - zrf = 64'hC80F13971AAD2E92; - ans = 64'hC80F13971AAD2E92; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4638155\n"); - end - xrf = 64'hBFCFFFC0000FFFFE; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h7FFFFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -355096,19 +103221,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -355124,387 +103249,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4638769\n"); + $fwrite(fp,"4422743\n"); end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hC80FFFFFFFFC007F; - zrf = 64'h40DAF0132A8CFF8E; - ans = 64'h481FFFFFFFFC007E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4639383\n"); - end - xrf = 64'hC01010000001FFFF; - y = 64'h7FF0000000000001; - zrf = 64'hC0CFFFFFFFFFDFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4639997\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h434000FFFFFFC000; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC35000FFFFFFC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4640611\n"); - end - xrf = 64'h7FDFFFFFC0007FFF; - y = 64'h29F163794782D658; - zrf = 64'h3FE3DD79ADFD87F7; - ans = 64'h69E1637924BC2956; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4641225\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h401FFFFFFFFFFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4641839\n"); - end - xrf = 64'h63500207FFFFFFFE; - y = 64'h3FBFFFFFFFFBFFE0; - zrf = 64'h3FD0000000000000; - ans = 64'h63200207FFFDFFAD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4642453\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h8000000000000000; - zrf = 64'h3CA00000000001EF; - ans = 64'h3CA00000000001EF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4643067\n"); - end - xrf = 64'h41C000003FFFFFE0; - y = 64'hBFFFFE000001FFFE; - zrf = 64'h1E9FFFBDFFFFFFFF; - ans = 64'hC1CFFE007FF9FFBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4643681\n"); - end - xrf = 64'hC02FFFFFDFFFFFE0; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h7FF0000000000000; + x = 64'h3C7BDD677D2DE8B2; + y = 64'h7FF0000000000000; + z = 64'hBFDFFBFFF8000000; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -355519,19 +103268,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -355547,12 +103296,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4644295\n"); + $fwrite(fp,"4424757\n"); end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hC3D95150EE4D41B2; - zrf = 64'hFFFFBFFFFFFFFFF6; - ans = 64'hFFFFBFFFFFFFFFF6; + x = 64'h3FBFFFFFFFFFF7BE; + y = 64'hC031F40CE9ABE276; + z = 64'hB7FFC10000000000; + ans = 64'hC001F40CE9ABDDD4; rn = 1; rz = 0; rm = 0; @@ -355566,19 +103315,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -355594,2690 +103343,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4644909\n"); + $fwrite(fp,"4426771\n"); end - xrf = 64'hB8D000007F7FFFFF; - y = 64'h8010000000000000; - zrf = 64'hBFA0087FFFFFFFFF; - ans = 64'hBFA0087FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4645523\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hBF800000800FFFFF; - zrf = 64'hC000000000000000; - ans = 64'hBFFFBFFFFDFFC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4646137\n"); - end - xrf = 64'hC1D0E27BE925288F; - y = 64'h27AEF17692609D73; - zrf = 64'h434865F1FE9C1F2A; - ans = 64'h434865F1FE9C1F2A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4646751\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h4010000000000000; - ans = 64'h4010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4647365\n"); - end - xrf = 64'hB80C6B7E325F4626; - y = 64'h298FFFFFFFF80000; - zrf = 64'h3CA0000000000001; - ans = 64'h3CA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4647979\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h38DE57676F5B535D; - ans = 64'h38DE57676F5B535D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4648593\n"); - end - xrf = 64'h001FFFFFFF6FFFFF; - y = 64'h18D000000003EFFF; - zrf = 64'h3FB07FFFF7FFFFFE; - ans = 64'h3FB07FFFF7FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4649207\n"); - end - xrf = 64'hB7E003FFFFFFFFC0; - y = 64'hBCA0000000000001; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4649821\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hC000000000083FFF; - zrf = 64'h321FF8FFFFFFFFFF; - ans = 64'h4010000000083FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4650435\n"); - end - xrf = 64'hB9E83EF5710A569E; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'hC03FFFFFFFFC0200; - ans = 64'hC03FFFFFFFFC0200; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4651049\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hB7F0040000080000; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4651663\n"); - end - xrf = 64'h358FF8000000007F; - y = 64'hC3F007FFFFFFFFFD; - zrf = 64'hBFB45E557C0369ED; - ans = 64'hBFB45E557C0369ED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4652277\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hBFD0000000000001; - zrf = 64'h4000000000000001; - ans = 64'h4004000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4652891\n"); - end - xrf = 64'h3E2000800000000F; - y = 64'hC1FFFF00000000FE; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'hC02FFFFFF800011C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4653505\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h3FCFFFFFFFFE0000; - ans = 64'h3FF3FFFFFFFFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4654119\n"); - end - xrf = 64'hA2767783997FEE24; - y = 64'h3DCB3B2CF2C797D1; - zrf = 64'h47FFFFFFFFFF00FF; - ans = 64'h47FFFFFFFFFF00FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4654733\n"); - end - xrf = 64'hBFEC00000000003E; - y = 64'hBFE0000000000000; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4655347\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hC00000008000007E; - zrf = 64'hC80FFFFFFFFFFBFD; - ans = 64'hC80FFFFFFFFFFBFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4655961\n"); - end - xrf = 64'hB80FFFFFFE001000; - y = 64'hBFE0000000000001; - zrf = 64'h381FFFFBFFFFFBFE; - ans = 64'h3823FFFDFFBFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4656575\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h4B0FFFFFFEFFFF7F; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hCB1FFFFFFEFFFF7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4657189\n"); - end - xrf = 64'hC3FE42B1B74222AF; - y = 64'hC060000040007FFF; - zrf = 64'hC34FDEFFFFFFFFFF; - ans = 64'h446E42AA388DDBA0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4657803\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hBFF0000000000000; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h400FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4658417\n"); - end - xrf = 64'h3F3E00000000007F; - y = 64'h3FD0041FFFFFFFFF; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h3F1E07BC0000007D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4659031\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hBFF0000000000001; - zrf = 64'h0F200083FFFFFFFE; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4659645\n"); - end - xrf = 64'h0000000000FF7FFF; - y = 64'h43F3FFFFFFF7FFFF; - zrf = 64'hC0CFF000000003FF; - ans = 64'hC0CFF000000003FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4660259\n"); - end - xrf = 64'h4070000003FFBFFE; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'hC07F800007FF7FFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4660873\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h3FD0FFFFFFFFFFFC; - zrf = 64'hB800000000240000; - ans = 64'hBFE0FFFFFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4661487\n"); - end - xrf = 64'hC7F00000001000FF; - y = 64'hC000000000000000; - zrf = 64'h3CA0000000018000; - ans = 64'h48000000001000FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4662101\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hB7E0000000000000; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4662715\n"); - end - xrf = 64'h37E0001FFFFFFFDE; - y = 64'hC7FAF4CF5154F9F1; - zrf = 64'h2C10000000020FFF; - ans = 64'hBFEAF5053AF39C62; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4663329\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h4021FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4663943\n"); - end - xrf = 64'h43B52930EB67766C; - y = 64'h3F4FFFFF00001FFF; - zrf = 64'h0000000000000000; - ans = 64'h43152930421E0439; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4664557\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hC010000000000000; - zrf = 64'h402454CFEDDF8220; - ans = 64'h40322A67F6EFC110; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4665171\n"); - end - xrf = 64'h3FFFFE0FFFFFFFFE; - y = 64'h43DFFC0000000003; - zrf = 64'hBFB54728FA4179FB; - ans = 64'h43EFFA103E000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4665785\n"); - end - xrf = 64'hBFCFFFFFFFFFFEE0; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h4010000000000000; - ans = 64'h4017FFFFFFFFFFB8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4666399\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h45E00000004007FE; - zrf = 64'hAB00100000020000; - ans = 64'hC5F00000004007FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4667013\n"); - end - xrf = 64'h3DC000008003FFFE; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h3DAFFFFE00000008; - ans = 64'hBDEE00012007FFF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4667627\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hC0000000FFFFFDFF; - zrf = 64'hBFD0000000000000; - ans = 64'h400E0001FFFFFBFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4668241\n"); - end - xrf = 64'h37E8D6C4ACEFFFD1; - y = 64'hC3DFFBFFFFFFFF00; - zrf = 64'h9AAB44387E45E5CF; - ans = 64'hBBD8D3A9D45A610A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4668855\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h3FE0000000000000; - ans = 64'h435FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4669469\n"); - end - xrf = 64'hC004EEF4EDA56F4F; - y = 64'h41DFEFFFFFFFEFFF; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4670083\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h7FFFE00000000000; - ans = 64'h7FFFE00000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4670697\n"); - end - xrf = 64'hFFD007FFFFFFFFFB; - y = 64'h3FFFFFF7FFFF0000; - zrf = 64'h43FFFFFFFE0000FF; - ans = 64'hFFE007FBFDFF7FBB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4671311\n"); - end - xrf = 64'hC07040000000007E; - y = 64'hFFE0000000000001; - zrf = 64'h4000000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4671925\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hB7EFFFFFFFFFE7FE; - zrf = 64'hC07FA3F4926F40F0; - ans = 64'hC07FA3F4926F40F0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4672539\n"); - end - xrf = 64'hC1EFFFFFBFFFFF7F; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h38160ECD5A0B670F; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4673153\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'h3803817952129C73; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4673767\n"); - end - xrf = 64'hFFF0002001000000; - y = 64'h3FE00004000FFFFF; - zrf = 64'h47FDFFFFFFFC0000; - ans = 64'hFFF8002001000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4674381\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hFFF0000000000001; - zrf = 64'h3FD0000000000001; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4674995\n"); - end - xrf = 64'h40BFFFFFFFFFC020; - y = 64'h3FD1008000000000; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4675609\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFF; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hC340000001000020; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4676223\n"); - end - xrf = 64'h381FFFFFFDFFFFBE; - y = 64'hBF8FFFFFE0000003; - zrf = 64'h402FFFFFFFFFC01E; - ans = 64'h402FFFFFFFFFC01E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4676837\n"); - end - xrf = 64'hC1C2FCBB9379E0FA; - y = 64'h0000000000000000; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4677451\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h43CFFFFE80000000; - zrf = 64'h40F000000000001D; - ans = 64'hC3DFFFFE7FFFFFBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4678065\n"); - end - xrf = 64'hD2B6D8B0E4FDE949; - y = 64'h0000000000000001; - zrf = 64'h0011FFFFFFFFFEFF; - ans = 64'h8F96D8B0E4FDE949; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4678679\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h7FE1287F22E0C8F2; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4679293\n"); - end - xrf = 64'h3EF00000000FF7FE; - y = 64'h46EF7BFFFFFFFFFF; - zrf = 64'h2DD01FFFFFFFFFF7; - ans = 64'h45EF7C00001F6C3D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4679907\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h0010000000000000; - zrf = 64'h3CAFFFFFFFFFFFFF; + x = 64'hBFEFFFFFFFFFFFFE; + y = 64'h8000000000000001; + z = 64'h3CAFFFFFFFFFFFFF; ans = 64'h3CAFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -358292,19 +103362,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -358320,2597 +103390,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4680521\n"); + $fwrite(fp,"4428785\n"); end - xrf = 64'hBFC4E649B0F696BB; - y = 64'hBCADA9D3FC28DCCA; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4681135\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h0010000000000001; - zrf = 64'h35CDD5BF21A50F02; - ans = 64'h35CDD5BF21A50F02; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4681749\n"); - end - xrf = 64'hBCAFDFFFFFFF7FFE; - y = 64'hBC7008000000003F; - zrf = 64'hA1B1000000004000; - ans = 64'h392FEFEFFFFF803C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4682363\n"); - end - xrf = 64'hC3D3C356A7C7A02B; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h3FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4682977\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h3D2FFFFFFFFFFFF5; - zrf = 64'h454E07FFFFFFFFFF; - ans = 64'h454E07FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4683591\n"); - end - xrf = 64'hC03FFFF7FFFFC000; - y = 64'h3CA0000000000000; - zrf = 64'hC3C08000000000FF; - ans = 64'hC3C08000000000FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4684205\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hC1CFBFFFFFFFFFDE; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h41DFBFFFFFFFFFDC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4684819\n"); - end - xrf = 64'h193FFFC000400000; - y = 64'hC3F0080007FFFFFF; - zrf = 64'h3800001FFFFFFFBF; - ans = 64'h3800001FFFFFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4685433\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'hBCBFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4686047\n"); - end - xrf = 64'hCEBFFFFDFFFFFFFF; - y = 64'hBFEFFFFFF77FFFFF; - zrf = 64'hC340000000000000; - ans = 64'h4EBFFFFDF7800086; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4686661\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h3FD0000000000000; - zrf = 64'h5CCFFFFFF03FFFFE; - ans = 64'h5CCFFFFFF03FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4687275\n"); - end - xrf = 64'hC6A0000FFFFFF7FE; - y = 64'hBF40080000200000; - zrf = 64'h00200200000FFFFE; - ans = 64'h45F00810081FF81A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4687889\n"); - end - xrf = 64'h7FF89749F3E80551; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h3FE0000000000000; - ans = 64'h7FF89749F3E80551; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4688503\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hBFE0800000000010; - zrf = 64'hC01FFFFFE7FFFFFE; - ans = 64'hC01BDFFFE7FFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4689117\n"); - end - xrf = 64'hBC8159724461C6B6; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h403FFFFFFFC00004; - ans = 64'h403FFFFFFFC00004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4689731\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hB8100FFFFFFFFFEF; - zrf = 64'h8000000000000000; - ans = 64'h38200FFFFFFFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4690345\n"); - end - xrf = 64'h3EC0FFFFFFFFFFFF; - y = 64'h801000000FFFFFBE; - zrf = 64'hC800008000000001; - ans = 64'hC800008000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4690959\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h0010000000000000; - ans = 64'hBFFFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4691573\n"); - end - xrf = 64'hC0200BFFFFFFFFFE; - y = 64'hBC1CD542664C602F; - zrf = 64'hC010000000000001; - ans = 64'hC010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4692187\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h7FF0008007FFFFFE; - ans = 64'h7FF8008007FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4692801\n"); - end - xrf = 64'h43D00000000000FF; - y = 64'hBFBFFE8000000000; - zrf = 64'h8000000003FEFFFE; - ans = 64'hC39FFE80000001FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4693415\n"); - end - xrf = 64'hBFB01DDD8BD5A220; - y = 64'h3FF0000000000001; - zrf = 64'h3FD0000000000001; - ans = 64'h3FC7F1113A152EF1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4694029\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h37E000007FFF8000; - zrf = 64'h3FFFFDFFFFFFFDFF; - ans = 64'h3FFFFDFFFFFFFDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4694643\n"); - end - xrf = 64'h480FFFFFFFFFFFBE; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h3FCAF4B83E9AF24B; - ans = 64'h481FFFFFFFFFFFBD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4695257\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hC2ECBB089215D588; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4695871\n"); - end - xrf = 64'hC052ABFBBD794F7D; - y = 64'hBD500000017FFFFE; - zrf = 64'h43CEDDC378BC15C2; - ans = 64'h43CEDDC378BC15C2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4696485\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h4000000000000001; - zrf = 64'h0000000000000001; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4697099\n"); - end - xrf = 64'h15E0002001FFFFFF; - y = 64'hC2C07FFFFFFFFFFC; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4697713\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h3E5FDFFFFE000000; - ans = 64'hC01FFFFFFE01FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4698327\n"); - end - xrf = 64'h37FA5D349DDA510F; - y = 64'hC01FFFDFFFFFFFFA; - zrf = 64'h47EF9EA0CF838EE5; - ans = 64'h47EF9EA0CF838EE5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4698941\n"); - end - xrf = 64'hC003FFFFFFFFFFFF; - y = 64'h4010000000000000; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hC023FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4699555\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hC96FFFFFEFFFFFF7; - zrf = 64'h000278E973277BE3; - ans = 64'h497FFFFFEFFFFFF5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4700169\n"); - end - xrf = 64'h0010000000010002; - y = 64'h4010000000000001; - zrf = 64'hC0E0100000003FFF; - ans = 64'hC0E0100000003FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4700783\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h3F94000100000000; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4701397\n"); - end - xrf = 64'hC19037D256F20CEA; - y = 64'h25A717C20B7C9256; - zrf = 64'hC3EFFFFFFFEFFFFD; - ans = 64'hC3EFFFFFFFEFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4702011\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4702625\n"); - end - xrf = 64'h0C5FFFFFFFF001FE; - y = 64'hC1FD7F84D115E0E3; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hBFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4703239\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h4340000000000001; - zrf = 64'hC01B3BCC1C3631FF; - ans = 64'hC350000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4703853\n"); - end - xrf = 64'hCF50000000000070; - y = 64'h3EA0DA1D7592A3AD; - zrf = 64'h400000041FFFFFFF; - ans = 64'hCE00DA1D7592A423; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4704467\n"); - end - xrf = 64'hCF81BD02FDBDCBCC; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'hD2E1BD02FDBDCBCB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4705081\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h43CFFFFFFFFE0FFF; - zrf = 64'hC010000080000800; - ans = 64'hC3DFFFFFFFFE0FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4705695\n"); - end - xrf = 64'hE6ABFFFBFFFFFFFF; - y = 64'h7FE0000000000000; - zrf = 64'hBFF0101000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4706309\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hB81FE0FFFFFFFFFF; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4706923\n"); - end - xrf = 64'hB90000FEFFFFFFFE; - y = 64'hBF6FFF6FFFFFFFFE; - zrf = 64'h41201FFFFFFFFFFF; - ans = 64'h41201FFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4707537\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4708151\n"); - end - xrf = 64'h3F9F800000FFFFFF; - y = 64'hBE7E0A9493F7DEC0; - zrf = 64'hBFF0000000000000; - ans = 64'hBFF0000000EC9352; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4708765\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h7FF0000000000000; - zrf = 64'h7FE0000400000010; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4709379\n"); - end - xrf = 64'hBFF0000400001FFE; - y = 64'h1500000000400006; - zrf = 64'h54C0A5DA83AAD051; - ans = 64'h54C0A5DA83AAD051; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4709993\n"); - end - xrf = 64'hC02FFFFFFFFE2000; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h0010000000000000; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4710607\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h43FBE36F649052DB; - zrf = 64'hBC629AAD2B6B5EAC; - ans = 64'hC40BE36F649052D9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4711221\n"); - end - xrf = 64'h002068F348044F2F; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h3FF00000000101FF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4711835\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hC00FE000003FFFFF; - zrf = 64'h4340000000000000; - ans = 64'h4340000000000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4712449\n"); - end - xrf = 64'hBC419D42438BA54B; - y = 64'h3FFFFFF7FFFF7FFE; - zrf = 64'hBFD0200000000007; - ans = 64'hBFD0200000000007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4713063\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h8000000000000001; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4713677\n"); - end - xrf = 64'hC01FFFFFFFFC0040; - y = 64'h3FF000000FFFEFFF; - zrf = 64'hBFE0000000000001; - ans = 64'hC02100000FFDF01F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4714291\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; + x = 64'hC7F000FDFFFFFFFE; y = 64'h800FFFFFFFFFFFFE; - zrf = 64'hC1CFFFFFFDFFFFFE; - ans = 64'hC1CFFFFFFDFFFFFE; + z = 64'h31225368A2EAE69C; + ans = 64'h31225368A2EAE69C; rn = 1; rz = 0; rm = 0; @@ -360924,19 +103409,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -360952,12 +103437,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4714905\n"); + $fwrite(fp,"4430799\n"); end - xrf = 64'hBFEFFFFFF7FFFFF6; - y = 64'hC3C4231ADE377F0D; - zrf = 64'hB7FFFFFFFFFFFF7F; - ans = 64'h43C4231AD92EB84F; + x = 64'hA3A0000000001000; + y = 64'hC7F0000000100040; + z = 64'h43B12238326B72C7; + ans = 64'h43B12238326B72C7; rn = 1; rz = 0; rm = 0; @@ -360971,19 +103456,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -360999,11714 +103484,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4715519\n"); + $fwrite(fp,"4432813\n"); end - xrf = 64'h3FD07DFFFFFFFFFE; - y = 64'h8010000000000001; - zrf = 64'h0000000000000001; - ans = 64'h80041F7FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4716133\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hB811777AA5BE6D08; - zrf = 64'hDE2FFFFDFEFFFFFF; - ans = 64'hDE2FFFFDFEFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4716747\n"); - end - xrf = 64'hBFE2000000000002; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'hC8AF8000001FFFFF; - ans = 64'hC8AF8000001FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4717361\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hC7FFFFFFFFFFE3FE; - zrf = 64'h4010000000000001; - ans = 64'h480FFFFFFFFFE3FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4717975\n"); - end - xrf = 64'h3F30000200003FFF; - y = 64'h413AF59B6E706523; - zrf = 64'h43ADFFFFFFFFBFFF; - ans = 64'h43ADFFFFFFFFC002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4718589\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; + x = 64'hBFEFFFFFFFFFFFFE; y = 64'hBCA0000000000000; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4719203\n"); - end - xrf = 64'h251FE01000000000; - y = 64'h380910E8005DBC03; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4719817\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h002FFFFF00003FFF; - ans = 64'h3CBFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4720431\n"); - end - xrf = 64'hC1EFFFFFFFFDFEFE; - y = 64'h419EFFFFEFFFFFFF; - zrf = 64'hFFF00000000001F8; - ans = 64'hFFF80000000001F8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4721045\n"); - end - xrf = 64'h403D515F4EB6A56F; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4721659\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hBCEFFFF8000FFFFF; - zrf = 64'hC01000013FFFFFFF; - ans = 64'hC01000013FFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4722273\n"); - end - xrf = 64'hC1C9E26D9096D42A; - y = 64'hBFD0000000000001; - zrf = 64'hBFFFC01000000000; - ans = 64'h41A9E26D8C9ED22C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4722887\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hC2D002001FFFFFFE; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h42E002002000007D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4723501\n"); - end - xrf = 64'hC02000FFFFFFFFC0; - y = 64'h3FD0000003BFFFFF; - zrf = 64'h37BFF80000800000; - ans = 64'hC000010003C03BBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4724115\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01BFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4724729\n"); - end - xrf = 64'hFFF2003FFFFFFFFF; - y = 64'hC1CF800000200000; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hFFFA003FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4725343\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hBFE0000000000001; - zrf = 64'h43400000003DFFFF; - ans = 64'h43400000003DFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4725957\n"); - end - xrf = 64'h37EFF000001FFFFE; - y = 64'hC3FFFFFFFE000000; - zrf = 64'h3A3FFFFFFF7FFF7E; - ans = 64'hBBFFEFFFFC20FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4726571\n"); - end - xrf = 64'hBFC3D1FDFA9C53C3; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4727185\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h480FFF000000001F; - zrf = 64'h382FEFFFFFFFFEFE; - ans = 64'hC81FFF000000001D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4727799\n"); - end - xrf = 64'hBE0FFE00000001FF; - y = 64'hBFF0000000000000; - zrf = 64'h3CC9D8CC4EC27673; - ans = 64'h3E0FFE019D8CC6EB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4728413\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h353FFFFE003FFFFF; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h3FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4729027\n"); - end - xrf = 64'h7FE01FFFF7FFFFFE; - y = 64'hBFEDD734385525CB; - zrf = 64'hC02FFFFFFFF00000; - ans = 64'hFFDE12E291DA35F7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4729641\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hBCBFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4730255\n"); - end - xrf = 64'hC1C04000000003FF; - y = 64'hBFC62A6CF7BEB206; - zrf = 64'hBCA0000000000000; - ans = 64'h41968316AB9DB257; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4730869\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hC000000000000000; - zrf = 64'hC8000000000003BE; - ans = 64'hC8000000000003BE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4731483\n"); - end - xrf = 64'hBF9FFEFFFFFFFEFE; - y = 64'h6B17FFFFFFFFFFFA; - zrf = 64'h5B200207FFFFFFFE; - ans = 64'hEAC7FF3FFFFFFF39; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4732097\n"); - end - xrf = 64'h270DFFFFFFFFFDFF; - y = 64'hC000000000000001; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4732711\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h452000FFFFFFFFBF; - zrf = 64'h6CEFFF8000FFFFFE; - ans = 64'h6CEFFF8000FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4733325\n"); - end - xrf = 64'hC1C7B64AFF58AE79; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'hFFFEEFFFFFFFFFFF; - ans = 64'hFFFEEFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4733939\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hC7FFFFFBFFEFFFFF; - zrf = 64'h3FF0000000000000; - ans = 64'h480FFFFBFFEFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4734553\n"); - end - xrf = 64'h3FCFFFFF80100000; - y = 64'h0BD01FFFFFEFFFFE; - zrf = 64'h40000000007FFFFE; - ans = 64'h40000000007FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4735167\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hC010000000000001; - zrf = 64'hC000000000000000; - ans = 64'h4018000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4735781\n"); - end - xrf = 64'h3FBFDFFFFFFF0000; - y = 64'h4010F1DCE8AABF76; - zrf = 64'h8010000000000001; - ans = 64'h3FE0E0EB0BC18D28; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4736395\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h40307FFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4737009\n"); - end - xrf = 64'h43A0020000000002; - y = 64'h3E3FFF7FFBFFFFFF; - zrf = 64'h40700400001FFFFF; - ans = 64'h41F001C00603C002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4737623\n"); - end - xrf = 64'h41C03FFFFFFFFFFB; - y = 64'hC340000000000000; - zrf = 64'hC340000000000001; - ans = 64'hC5104000007FFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4738237\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h43C000FFFFFFC000; - zrf = 64'hBFCA8EC2D50C91A8; - ans = 64'hC3D000FFFFFFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4738851\n"); - end - xrf = 64'h43CFF9FFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h3D319B696BEFF98C; - ans = 64'hC72FF9FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4739465\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hC7E00020000FFFFE; - zrf = 64'h3FE0000000000001; - ans = 64'h47F00020000FFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4740079\n"); - end - xrf = 64'h8160003FFFBFFFFE; - y = 64'hC00FDC0C066ADECE; - zrf = 64'hBC8000000000FFDF; - ans = 64'hBC8000000000FFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4740693\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hFFE0000000000000; - zrf = 64'hBFF0000000000001; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4741307\n"); - end - xrf = 64'h3FEFFEBFFFFFFFFE; - y = 64'h41DFFFFF803FFFFE; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h41DFFEBF8044FD7C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4741921\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hE0CFFFEFFFFC0000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4742535\n"); - end - xrf = 64'h401FFFFFFFFFFEEF; - y = 64'hC7E17FFFFFFFFFFE; - zrf = 64'h47EC89D370A47C96; - ans = 64'hC80BDD8B23D6DFAC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4743149\n"); - end - xrf = 64'h43F010000000001F; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4743763\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hC00FFFFC000003FF; - zrf = 64'h49311FFFFFFFFFFF; - ans = 64'h49311FFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4744377\n"); - end - xrf = 64'hC3F95BEC63B93917; - y = 64'hFFF0000000000001; - zrf = 64'hC175E02580E7A46E; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4744991\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'h3CA00000007FFFFF; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FDFFFFFFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4745605\n"); - end - xrf = 64'hC10FFFFF00000007; - y = 64'h3E9FFFFFFCFFFFFF; - zrf = 64'hBFF00000FFFFFE00; - ans = 64'hBFF20000EFCFFE02; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4746219\n"); - end - xrf = 64'hBFFFFFFFFFFFFFFE; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'hBFEFFFFFFFFFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4746833\n"); - end - xrf = 64'h3F80000002010000; - y = 64'h40BFFFFFFFFFFEFA; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4747447\n"); - end - xrf = 64'hC000000000000000; - y = 64'h0000000000000001; - zrf = 64'hC037D15B58C19903; - ans = 64'hC037D15B58C19903; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4748061\n"); - end - xrf = 64'h3C7FFFFFFFFFFFAE; - y = 64'hCEC00003FFFFF7FE; - zrf = 64'h7FFFFF7FFBFFFFFF; - ans = 64'h7FFFFF7FFBFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4748675\n"); - end - xrf = 64'hBCAFFFDBFFFFFFFF; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4749289\n"); - end - xrf = 64'hC000000000000000; - y = 64'h002FFFF800000200; - zrf = 64'hBB7000000003BFFE; - ans = 64'hBB7000000003BFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4749903\n"); - end - xrf = 64'h37F537BB759A73AA; - y = 64'h0010000000000000; - zrf = 64'hC04BFDFFFFFFFFFF; - ans = 64'hC04BFDFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4750517\n"); - end - xrf = 64'hC000000000000000; - y = 64'h4768B8763D78C258; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'hC778B8763D78C258; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4751131\n"); - end - xrf = 64'hB0714BCB37C81AA4; - y = 64'h2A9200000000003F; - zrf = 64'hCEE3C779BD49CF2F; - ans = 64'hCEE3C779BD49CF2F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4751745\n"); - end - xrf = 64'hC000000000000000; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4752359\n"); - end - xrf = 64'h3FF000001FFFFFF7; - y = 64'h40EFEFFFFFE00000; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4752973\n"); - end - xrf = 64'hC000000000000000; - y = 64'h3CA0000000000000; - zrf = 64'h3FE0000000000030; - ans = 64'h3FE000000000002E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4753587\n"); - end - xrf = 64'h3FBFFFF002000000; - y = 64'h7FE0080000004000; - zrf = 64'h3CFFFFFFFFFFFBE0; - ans = 64'h7FB007F7FD00C000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4754201\n"); - end - xrf = 64'hBFC0000400000000; - y = 64'h3CA0000000000001; - zrf = 64'hC000000000000000; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4754815\n"); - end - xrf = 64'hC000000000000000; - y = 64'h322FFFFFFE03FFFF; - zrf = 64'hBEB10000007FFFFE; - ans = 64'hBEB10000007FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4755429\n"); - end - xrf = 64'h47F83807FC6D7EC6; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'hC9A07FFFFFFF0000; - ans = 64'hC9A07FFFFFFF0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4756043\n"); - end - xrf = 64'hC000000000000000; - y = 64'h3FE000000FFFDFFF; - zrf = 64'h3CA0000000000000; - ans = 64'hBFF000000FFFDFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4756657\n"); - end - xrf = 64'h43DFFFFFFDFFFFF7; - y = 64'hBFDFFBFFFFFFDFFF; - zrf = 64'h48000010000001FE; - ans = 64'h48000010000001FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4757271\n"); - end - xrf = 64'hC000000000000000; - y = 64'h3FD0000000000001; - zrf = 64'hBFD0000000000000; - ans = 64'hBFE8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4757885\n"); - end - xrf = 64'hBF1FFFFFF7BFFFFF; - y = 64'hBC707FFBFFFFFFFF; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4758499\n"); - end - xrf = 64'hC000000000000000; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h4018C80DA94BC2E6; - ans = 64'h4014C80DA94BC2E6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4759113\n"); - end - xrf = 64'hC7E132862B7DF216; - y = 64'h3D200000000002FF; - zrf = 64'h40225B8A19EA1026; - ans = 64'hC51132862B7DF54E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4759727\n"); - end - xrf = 64'hBFEFFFBEFFFFFFFF; - y = 64'h3FE0000000000000; - zrf = 64'hBFF0000000000001; - ans = 64'hBFF7FFEFC0000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4760341\n"); - end - xrf = 64'hC000000000000000; - y = 64'h405FFF0000001000; - zrf = 64'h43FFFFF000000000; - ans = 64'h43FFFFF000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4760955\n"); - end - xrf = 64'h405000003FFFFFFF; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'hC3E1B08CE72B9807; - ans = 64'hC3E1B08CE72B9807; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4761569\n"); - end - xrf = 64'hC000000000000000; - y = 64'hBFBFFFFFF00FFFFE; - zrf = 64'h0010000000000001; - ans = 64'h3FCFFFFFF00FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4762183\n"); - end - xrf = 64'h47F03BFFFFFFFFFE; - y = 64'hBCFE5C2E9294CE15; - zrf = 64'h345FC0003FFFFFFF; - ans = 64'hC4FECE08413A7C16; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4762797\n"); - end - xrf = 64'hC000000000000000; - y = 64'h3FF0000000000000; - zrf = 64'hBCA0000000000001; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4763411\n"); - end - xrf = 64'h7FF000000001000F; - y = 64'hC02FFFFFDF7FFFFE; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h7FF800000001000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4764025\n"); - end - xrf = 64'hC000000000000000; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h3CBFD937240A18E3; - ans = 64'hC00FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4764639\n"); - end - xrf = 64'hBFCE8C58A9CD4DA5; - y = 64'hC12FFFC000000002; - zrf = 64'h47EC1956FF4B8CEA; - ans = 64'h47EC1956FF4B8CEA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4765253\n"); - end - xrf = 64'h4800FFFFFFFDFFFE; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'h4810FFFFFFFDFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4765867\n"); - end - xrf = 64'hC000000000000000; - y = 64'h401FFC00003FFFFF; - zrf = 64'h7FF00200000001FE; - ans = 64'h7FF80200000001FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4766481\n"); - end - xrf = 64'hBEE0000020000000; - y = 64'h4000000000000001; - zrf = 64'hC03010000000FFFE; - ans = 64'hC0301001000101FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4767095\n"); - end - xrf = 64'hC000000000000000; - y = 64'hC3EFFDFFFFFF7FFE; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h43FFFDFFFFFF7FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4767709\n"); - end - xrf = 64'h801682810B99A0B7; - y = 64'hC1DFFFFFFFFC0010; - zrf = 64'hB7FFFFFFFF000002; - ans = 64'hB7FFFFFFFF000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4768323\n"); - end - xrf = 64'hC000000000000000; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4768937\n"); - end - xrf = 64'hE047BF8FAA9CD48B; - y = 64'hC45DAB0F19301D81; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h64B6048D0ED28C21; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4769551\n"); - end - xrf = 64'hC000000000000000; - y = 64'h4010000000000001; - zrf = 64'h31AFFFFFF001FFFF; - ans = 64'hC020000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4770165\n"); - end - xrf = 64'hC28000000040007F; - y = 64'hFFFACC9FD9BF2817; - zrf = 64'h477D4B7A75BCF50E; - ans = 64'hFFFACC9FD9BF2817; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4770779\n"); - end - xrf = 64'hC3E00004007FFFFF; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hC4100004007FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4771393\n"); - end - xrf = 64'hC000000000000000; - y = 64'hDA2EFFFFFFFFFFEE; - zrf = 64'h37EFFFFFFDFFFFDE; - ans = 64'h5A3EFFFFFFFFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4772007\n"); - end - xrf = 64'h1D100001FC000000; - y = 64'h4340000000000000; - zrf = 64'h3FE01FFFFFFFFFFE; - ans = 64'h3FE01FFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4772621\n"); - end - xrf = 64'hC000000000000000; - y = 64'hC0B5F99DB0997163; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4773235\n"); - end - xrf = 64'h002FFF2000000000; - y = 64'hC01000001FF80000; - zrf = 64'hC0F0000000006000; - ans = 64'hC0F0000000006000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4773849\n"); - end - xrf = 64'hC000000000000000; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hC35FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4774463\n"); - end - xrf = 64'hC1C61EAE1091F88B; - y = 64'hBFC003FFFFFFFF7F; - zrf = 64'h4010000000000000; - ans = 64'h41962435CC161C57; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4775077\n"); - end - xrf = 64'hC000000000000000; - y = 64'h7FE0000000000000; - zrf = 64'hB490008800000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4775691\n"); - end - xrf = 64'h3FF000000000100F; - y = 64'hC03E000000003FFF; - zrf = 64'hBF780000FFFFFFFF; - ans = 64'hC03E018000105E1B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4776305\n"); - end - xrf = 64'hBFF0000000087FFF; - y = 64'h7FE0000000000001; - zrf = 64'hBFD0000000000000; - ans = 64'hFFE0000000088000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4776919\n"); - end - xrf = 64'hC000000000000000; - y = 64'hAF9000000001FFFC; - zrf = 64'hC3C000000001FFE0; - ans = 64'hC3C000000001FFE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4777533\n"); - end - xrf = 64'h4004078C445DB188; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hE88FF7FFFFFFFDFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4778147\n"); - end - xrf = 64'hC000000000000000; - y = 64'hC57FFC00007FFFFF; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4778761\n"); - end - xrf = 64'h566D6ACA294B47DC; - y = 64'h80200000001FBFFF; - zrf = 64'h7FD00400007FFFFE; - ans = 64'h7FD00400007FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4779375\n"); - end - xrf = 64'hC000000000000000; - y = 64'h7FF0000000000001; - zrf = 64'h8000000000000000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4779989\n"); - end - xrf = 64'h41410000007FFFFF; - y = 64'hFFFFFF000001FFFF; - zrf = 64'h4000000000000001; - ans = 64'hFFFFFF000001FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4780603\n"); - end - xrf = 64'hC000000000000000; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h3AB000000002FFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4781217\n"); - end - xrf = 64'h41E07FFFFF7FFFFE; - y = 64'hC1D4EB60BD7135BC; - zrf = 64'h43CEAE71FC4AC2A3; - ans = 64'h43B2376C732ABC83; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4781831\n"); - end - xrf = 64'hC02000000000013F; - y = 64'h8000000000000000; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4782445\n"); - end - xrf = 64'hC000000000000000; - y = 64'hC1C000407FFFFFFF; - zrf = 64'h43CB22E1D77F203F; - ans = 64'h43CB22E1D79F20C0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4783059\n"); - end - xrf = 64'hFFD41AE46BFFE4EA; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h3FEFFF7FFFFBFFFE; - ans = 64'h40020D5235FEF274; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4783673\n"); - end - xrf = 64'hC000000000000000; - y = 64'h403FFFE000000FFF; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4784287\n"); - end - xrf = 64'h41EF0000003FFFFF; - y = 64'h0EAFFEFFFFFFFE00; - zrf = 64'hC3751594064F2D16; - ans = 64'hC3751594064F2D16; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4784901\n"); - end - xrf = 64'hC000000000000000; - y = 64'h8010000000000000; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4785515\n"); - end - xrf = 64'h3CA01FFFFFFFFFFB; - y = 64'h43F000000003FFFC; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h40A02400000407F7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4786129\n"); - end - xrf = 64'hC000000000000000; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h8014001000000000; - ans = 64'h0025FFF7FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4786743\n"); - end - xrf = 64'h47F007FFFDFFFFFE; - y = 64'hC03BFFFFF7FFFFFF; - zrf = 64'h407FE1FFFFFFFFFF; - ans = 64'hC83C0DFFF47BFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4787357\n"); - end - xrf = 64'h3FFB9F4B3B880797; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h8035CFA59DC403CA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4787971\n"); - end - xrf = 64'hC000000000000000; - y = 64'hC17EAFB15B81E5C5; - zrf = 64'hC0008000000FFFFF; - ans = 64'h418EAFB14B01E5C5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4788585\n"); - end - xrf = 64'h37FC7F9C32D8F80B; - y = 64'hBCA0000000000001; - zrf = 64'hBFD2E838DEE5EB0C; - ans = 64'hBFD2E838DEE5EB0C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4789199\n"); - end - xrf = 64'hC000000000000000; - y = 64'h802FFF8008000000; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4789813\n"); - end - xrf = 64'h3FEECD9312517432; - y = 64'h401FFF8000000001; - zrf = 64'h47F381060C3164D9; - ans = 64'h47F381060C3164D9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4790427\n"); - end - xrf = 64'hC000000000000000; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4791041\n"); - end - xrf = 64'h4800000000047FFF; - y = 64'h381DD835503ACC9D; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h402FD8355043316A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4791655\n"); - end - xrf = 64'hC000000000000000; - y = 64'hBFD0000000000000; - zrf = 64'hBFE090DA4ABFBE57; - ans = 64'hBF921B4957F7CAE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4792269\n"); - end - xrf = 64'h43C00FFFFFFFFF00; - y = 64'hC7E01FFFFFFFBFFE; - zrf = 64'h3FAFFFFFFF8FFFFF; - ans = 64'hCBB0301FFFFFBEBC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4792883\n"); - end - xrf = 64'h496FFFFFFBFFFEFF; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hC95FFFFFFBFFFEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4793497\n"); - end - xrf = 64'hC000000000000000; - y = 64'hBF9040007FFFFFFE; - zrf = 64'h3FFA598934541F7F; - ans = 64'h3FFADB8938541F7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4794111\n"); - end - xrf = 64'hC332ACCF1171F2D2; - y = 64'hBFE0000000000000; - zrf = 64'h37EFFFFEFFFFFFEF; - ans = 64'h4322ACCF1171F2D2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4794725\n"); - end - xrf = 64'hC000000000000000; - y = 64'hFFF0000000100002; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hFFF8000000100002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4795339\n"); - end - xrf = 64'hC02FC0000000001F; - y = 64'h3292387D2959F433; - zrf = 64'hC09FFFFFFD7FFFFF; - ans = 64'hC09FFFFFFD7FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4795953\n"); - end - xrf = 64'hC000000000000000; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4796567\n"); - end - xrf = 64'h3D920FFFFFFFFFFF; - y = 64'h47F2003FFFFFFFFE; - zrf = 64'h3FE0000000000000; - ans = 64'h459452483FFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4797181\n"); - end - xrf = 64'hC000000000000000; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hC3DFFFFFFF007FFE; - ans = 64'hC3DFFFFFFF007FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4797795\n"); - end - xrf = 64'hC0036AC481BF775F; - y = 64'h3F2000800000001E; - zrf = 64'hD7FFFFEFEFFFFFFE; - ans = 64'hD7FFFFEFEFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4798409\n"); - end - xrf = 64'h434FFFFFF7FFFFF6; - y = 64'hBFF0000000000001; - zrf = 64'h8000000000000000; - ans = 64'hC34FFFFFF7FFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4799023\n"); - end - xrf = 64'hC000000000000000; - y = 64'hC36000003F7FFFFF; - zrf = 64'hC1C01000000001FF; - ans = 64'h437000003D7DFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4799637\n"); - end - xrf = 64'hBFFFB35708D56994; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hFFF00000000005FE; - ans = 64'hFFF80000000005FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4800251\n"); - end - xrf = 64'hC000000000000000; - y = 64'h3CA0011FFFFFFFFF; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4800865\n"); - end - xrf = 64'h401EBEE752B17CD9; - y = 64'hC0132B9FADF5B010; - zrf = 64'h3FB057C9E0B68A66; - ans = 64'hC042631766B1A999; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4801479\n"); - end - xrf = 64'hC000000000000000; - y = 64'hC000000000000001; - zrf = 64'h4340000000000000; - ans = 64'h4340000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4802093\n"); - end - xrf = 64'h7FD42CC5B90AE79C; - y = 64'hAE1FFFFFFFFFFFFF; - zrf = 64'h3FD0000000000001; - ans = 64'hEE042CC5B90AE79B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4802707\n"); - end - xrf = 64'hC000000000000000; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h43CF840000000000; - ans = 64'h43CF840000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4803321\n"); - end - xrf = 64'h43E020000000001F; - y = 64'h37EFFFF800000007; - zrf = 64'hC3D6C3593D1FDF64; - ans = 64'hC3D6C3593D1FDF64; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4803935\n"); - end - xrf = 64'hC2100000007FE000; - y = 64'hC010000000000000; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4804549\n"); - end - xrf = 64'hC000000000000000; - y = 64'hC00FFFFFBFFFF7FF; - zrf = 64'hB813A2E28D5AD71E; - ans = 64'h401FFFFFBFFFF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4805163\n"); - end - xrf = 64'h2680040000080000; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hBE40000400000007; - ans = 64'hBE40000400000007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4805777\n"); - end - xrf = 64'hC000000000000000; - y = 64'h43E6105B342881F3; - zrf = 64'hC000000000000001; - ans = 64'hC3F6105B342881F3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4806391\n"); - end - xrf = 64'h41FF6BB8087D854E; - y = 64'h000FFFFFE7FFFFFF; - zrf = 64'hFFD00000800FFFFF; - ans = 64'hFFD00000800FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4807005\n"); - end - xrf = 64'hC000000000000000; - y = 64'hC340000000000000; - zrf = 64'h4010000000000001; - ans = 64'h4350000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4807619\n"); - end - xrf = 64'hC1D000000000FFFC; - y = 64'hBF6FFFFFFFFFFF08; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h415000000000FF80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4808233\n"); - end - xrf = 64'hC000000000000000; - y = 64'hC340000000000001; - zrf = 64'h3F60000000000043; - ans = 64'h4350000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4808847\n"); - end - xrf = 64'hCFA1C3B5C679ECE0; - y = 64'hC0010000000003FF; - zrf = 64'hB81000007FFFFDFF; - ans = 64'h4FB2DFF122E1901E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4809461\n"); - end - xrf = 64'h43DA79073B0870AA; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4810075\n"); - end - xrf = 64'hC000000000000000; - y = 64'h3CEFFFFFFFFE01FF; - zrf = 64'hC1F0201000000000; - ans = 64'hC1F0201000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4810689\n"); - end - xrf = 64'h43E000010003FFFF; - y = 64'hFFE0000000000000; - zrf = 64'hB801FFEFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4811303\n"); - end - xrf = 64'hC000000000000000; - y = 64'h46400FFFFDFFFFFE; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hC6500FFFFDFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4811917\n"); - end - xrf = 64'hC250003FF7FFFFFF; - y = 64'hDC4FFFFFFFF0000E; - zrf = 64'hBFD0000F7FFFFFFF; - ans = 64'h5EB0003FF7F7FFE6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4812531\n"); - end - xrf = 64'hC000000000000000; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4813145\n"); - end - xrf = 64'hD5BFFFFFFFF7F800; - y = 64'hBF9FFFFF9FFFFFFF; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h556FFFFF9FF7F7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4813759\n"); - end - xrf = 64'hC000000000000000; - y = 64'hFFF0000000000000; - zrf = 64'hC1FFFFFFBFFF8000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4814373\n"); - end - xrf = 64'h43EA2CA46F5C0A22; - y = 64'h7FEFFFFFFF001FFF; - zrf = 64'h001000001FDFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4814987\n"); - end - xrf = 64'hC3EDC16782F5AB6E; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4815601\n"); - end - xrf = 64'hC000000000000000; - y = 64'hBCA3FFFFFFFFFEFE; - zrf = 64'hB800000000080400; - ans = 64'h3CB3FFFFFFFFFEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4816215\n"); - end - xrf = 64'h43D000FFFFFFF800; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'hBB40000800080000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4816829\n"); - end - xrf = 64'hC000000000000001; - y = 64'h3FF07FFFFFEFFFFE; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hC0087FFFFFEFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4817443\n"); - end - xrf = 64'hC00FFFBFFFFFFEFF; - y = 64'h47EFFFC0001FFFFF; - zrf = 64'hC030000FFFFFBFFF; - ans = 64'hC80FFF80009FFEBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4818057\n"); - end - xrf = 64'hC000000000000001; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h3FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4818671\n"); - end - xrf = 64'hC1FE0000007FFFFE; - y = 64'hC80FFDFFFFFF7FFF; - zrf = 64'h0010000000000000; - ans = 64'h4A1DFE20007F7FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4819285\n"); - end - xrf = 64'hC000000000000001; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h3FE000800000003F; - ans = 64'h3FE000800000003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4819899\n"); - end - xrf = 64'hFFE1FFFFDFFFFFFF; - y = 64'hB8100000020007FE; - zrf = 64'h41D1000000003FFE; - ans = 64'h7801FFFFE24008F9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4820513\n"); - end - xrf = 64'hC7F000EFFFFFFFFE; - y = 64'h0010000000000001; - zrf = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4821127\n"); - end - xrf = 64'hC000000000000001; - y = 64'h4020003FFFFFFFBF; - zrf = 64'h3FBFFFFFFF80000E; - ans = 64'hC02FC0800000FF80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4821741\n"); - end - xrf = 64'h3F0F00001FFFFFFE; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h380FFFFFFFFFFEDF; - ans = 64'h380FFFFFFFFFFEDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4822355\n"); - end - xrf = 64'hC000000000000001; - y = 64'hC830000000007F7F; - zrf = 64'hBFE0000000000000; - ans = 64'h4840000000007F80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4822969\n"); - end - xrf = 64'hE8DFF7FFFBFFFFFF; - y = 64'hC1EFFFFFFFF3FFFE; - zrf = 64'h402FFFE00001FFFF; - ans = 64'h6ADFF7FFFBF402FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4823583\n"); - end - xrf = 64'hC000000000000001; - y = 64'h3CA0000000000001; - zrf = 64'h3FF0000000000000; - ans = 64'h3FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4824197\n"); - end - xrf = 64'h39A6772140800FB3; - y = 64'hC3CEC249A02BD458; - zrf = 64'h0000000000000001; - ans = 64'hBD85981516455DA5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4824811\n"); - end - xrf = 64'hC000000000000001; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hC2683D3E2977C792; - ans = 64'hC2683D3E2977C792; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4825425\n"); - end - xrf = 64'h4002C8E061322F1C; - y = 64'h480FBC727BCD770B; - zrf = 64'h47F00000BFFFFFFE; - ans = 64'h4824A138D0AFB9EF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4826039\n"); - end - xrf = 64'h2380000003FFFDFE; - y = 64'h3FD0000000000000; - zrf = 64'h4010000000000001; - ans = 64'h4010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4826653\n"); - end - xrf = 64'hC000000000000001; - y = 64'h94C63A9BC835E4F2; - zrf = 64'hC7F0001FFFFFFFF7; - ans = 64'hC7F0001FFFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4827267\n"); - end - xrf = 64'h41EFFFFFF0007FFF; - y = 64'h3FD0000000000001; - zrf = 64'hC01003FFBFFFFFFF; - ans = 64'h41CFFFFFEE000009; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4827881\n"); - end - xrf = 64'hC000000000000001; - y = 64'h3F70020000003FFF; - zrf = 64'hBFD0000000000001; - ans = 64'hBFD0801000000201; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4828495\n"); - end - xrf = 64'h7FFF1F50F91ED3D0; - y = 64'h47F0FFFFFBFFFFFF; - zrf = 64'h802243711260BDDE; - ans = 64'h7FFF1F50F91ED3D0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4829109\n"); - end - xrf = 64'hC000000000000001; - y = 64'h3FE0000000000000; - zrf = 64'h3FE0000000000001; - ans = 64'hBFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4829723\n"); - end - xrf = 64'h800002000001FFFE; - y = 64'h3CADB3970DA09FB0; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4830337\n"); - end - xrf = 64'hC000000000000001; - y = 64'h3FE0000000000001; - zrf = 64'h3D5FFFFFFFFFFFF6; - ans = 64'hBFEFFFFFFFFFF004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4830951\n"); - end - xrf = 64'h41DFFFF7FFC00000; - y = 64'h3FAC216014AA7BEF; - zrf = 64'h3FE0000FFFF80000; - ans = 64'h419C21590E1A3604; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4831565\n"); - end - xrf = 64'hBCA0004FFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h400FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4832179\n"); - end - xrf = 64'hC000000000000001; - y = 64'hFFEFFFFF88000000; - zrf = 64'hC1E003F7FFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4832793\n"); - end - xrf = 64'h3FF51318FC907CFD; - y = 64'h3FF0000000000000; - zrf = 64'hC06C6BE3A1DD8339; - ans = 64'hC06C41BD6FE4623F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4833407\n"); - end - xrf = 64'hC000000000000001; - y = 64'hBCA0002000000002; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h3BC000000001C001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4834021\n"); - end - xrf = 64'h3FDFFFFFF7FFBFFF; - y = 64'h403ED2FC247122C7; - zrf = 64'hC1C00FFFFFFFFBFE; - ans = 64'hC1C00FFFF84B3CF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4834635\n"); - end - xrf = 64'hC000000000000001; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'hC00C000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4835249\n"); - end - xrf = 64'h059739E06AA259B1; - y = 64'hBFEFFF8000000000; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4835863\n"); - end - xrf = 64'hC000000000000001; - y = 64'h4000000000000000; - zrf = 64'h381FFFDFFEFFFFFE; - ans = 64'hC010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4836477\n"); - end - xrf = 64'hBF0E1FFFFFFFFFFF; - y = 64'h3821FFDFFFFFFFFF; - zrf = 64'hFFF001FBFFFFFFFE; - ans = 64'hFFF801FBFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4837091\n"); - end - xrf = 64'h3FFFFFFFFEFFFF7E; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h4023FFFFFF7FFFBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4837705\n"); - end - xrf = 64'hC000000000000001; - y = 64'hC1DFFDFFFFFFFBFF; - zrf = 64'hBFF0000FFFFFFFBE; - ans = 64'h41EFFDFFFFDFFBE1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4838319\n"); - end - xrf = 64'hB850373CB13E887F; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hE7900003FFEFFFFE; - ans = 64'hE7900003FFEFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4838933\n"); - end - xrf = 64'hC000000000000001; - y = 64'h00000000004FFFFF; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h80200000004FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4839547\n"); - end - xrf = 64'h3FB2000003FFFFFF; - y = 64'hBB9FF7FFFFFFFFFC; - zrf = 64'h401FFEFFFFFFFFDE; - ans = 64'h401FFEFFFFFFFFDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4840161\n"); - end - xrf = 64'hC000000000000001; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'hC030000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4840775\n"); - end - xrf = 64'hC1F000002000003F; - y = 64'h3FE0000000010001; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4841389\n"); - end - xrf = 64'hC000000000000001; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h43DFFFF820000000; - ans = 64'h43DFFFF820000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4842003\n"); - end - xrf = 64'h802FFFFFC001FFFF; - y = 64'h001F90546B1F820D; - zrf = 64'h2240100000007FFF; - ans = 64'h2240100000007FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4842617\n"); - end - xrf = 64'h3CA58D8410EF6524; - y = 64'h4340000000000001; - zrf = 64'h3FF0000000000000; - ans = 64'h4002C6C20877B293; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4843231\n"); - end - xrf = 64'hC000000000000001; - y = 64'h6A9FFEFFFFFE0000; - zrf = 64'hC3F59178CB3E497A; - ans = 64'hEAAFFEFFFFFE0002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4843845\n"); - end - xrf = 64'h802FFFFEFFFBFFFE; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'hC9A000FFFFFFFFDF; - ans = 64'hC9A000FFFFFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4844459\n"); - end - xrf = 64'hC000000000000001; - y = 64'hBFD00007C0000000; - zrf = 64'h8010000000000000; - ans = 64'h3FE00007C0000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4845073\n"); - end - xrf = 64'hFFEFFFFEFFFFEFFE; - y = 64'h80D84CF2726BC1E7; - zrf = 64'h43C00000010000FF; - ans = 64'h43C0000001000130; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4845687\n"); - end - xrf = 64'hC000000000000001; - y = 64'h7FE0000000000001; - zrf = 64'h3CA0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4846301\n"); - end - xrf = 64'h403FFFFFFF800000; - y = 64'h7FF79D944590A93E; - zrf = 64'hC340000000000001; - ans = 64'h7FFF9D944590A93E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4846915\n"); - end - xrf = 64'hC000000000000001; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hC7EFFFFF7FFFFFE0; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4847529\n"); - end - xrf = 64'h4030000007EFFFFF; - y = 64'hB80FFFE001000000; - zrf = 64'h41DFF800000000FE; - ans = 64'h41DFF800000000FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4848143\n"); - end - xrf = 64'hC1301FFFFFFFDFFF; - y = 64'h7FF0000000000000; - zrf = 64'h3FE0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4848757\n"); - end - xrf = 64'hC000000000000001; - y = 64'h380FFFE0000007FF; - zrf = 64'h43EFFFFFFF001FFE; - ans = 64'h43EFFFFFFF001FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4849371\n"); - end - xrf = 64'h40A0000000041000; - y = 64'h7FF0000000000001; - zrf = 64'hFFD000FFFFFFFFBF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4849985\n"); - end - xrf = 64'hC000000000000001; - y = 64'h3FE0000000400008; - zrf = 64'h8000000000000001; - ans = 64'hBFF0000000400009; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4850599\n"); - end - xrf = 64'h7FFFFFFBFFFFFFEF; - y = 64'h412FFFF7FFE00000; - zrf = 64'h4800007F7FFFFFFF; - ans = 64'h7FFFFFFBFFFFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4851213\n"); - end - xrf = 64'hC000000000000001; - y = 64'h8000000000000000; - zrf = 64'h0010000000000001; - ans = 64'h0010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4851827\n"); - end - xrf = 64'h402000800FFFFFFE; - y = 64'hC1E000003FFFDFFE; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC21000805021E03B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4852441\n"); - end - xrf = 64'hC000000000000001; - y = 64'h8000000000000001; - zrf = 64'h3FDFA9BCBFEBECC4; - ans = 64'h3FDFA9BCBFEBECC4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4853055\n"); - end - xrf = 64'h404FF07FFFFFFFFE; - y = 64'h001C000000001FFF; - zrf = 64'h402F7FFFFFDFFFFF; - ans = 64'h402F7FFFFFDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4853669\n"); - end - xrf = 64'hC3EBFD8B5056AC25; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4854283\n"); - end - xrf = 64'hC000000000000001; - y = 64'h4003FFFFFFDFFFFF; - zrf = 64'hC3400DFFFFFFFFFF; - ans = 64'hC3400E0000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4854897\n"); - end - xrf = 64'h7FE0500000000000; - y = 64'h8010000000000000; - zrf = 64'h707FFFFFAFFFFFFF; - ans = 64'h707FFFFFAFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4855511\n"); - end - xrf = 64'hC000000000000001; - y = 64'hC9680003FFFFFFFF; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4856125\n"); - end - xrf = 64'hB81000000FFFFFDF; - y = 64'hC11000000FFF8000; - zrf = 64'hBFDBFFFFFFFFBFFF; - ans = 64'hBFDBFFFFFFFFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4856739\n"); - end - xrf = 64'hC000000000000001; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h0034000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4857353\n"); - end - xrf = 64'hBF79772B9378E71D; - y = 64'h41F6CE7DA33C263E; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC18226413951951C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4857967\n"); - end - xrf = 64'hC000000000000001; - y = 64'hBCA0000000000000; - zrf = 64'h3F4FFFFFFFFDFFFF; - ans = 64'h3F4FFFFFFFFE07FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4858581\n"); - end - xrf = 64'hC01FFF7FFFFFFBFF; - y = 64'hFF9000000007FFF8; - zrf = 64'hC1E000BFFFFFFFFF; - ans = 64'h7FBFFF80000FFBAF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4859195\n"); - end - xrf = 64'hC3C0000000407FFF; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h4080000000407FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4859809\n"); - end - xrf = 64'hC000000000000001; - y = 64'h800FFFFFFFFFF77E; - zrf = 64'hBFF7524CE0B24DC8; - ans = 64'hBFF7524CE0B24DC8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4860423\n"); - end - xrf = 64'h434000000000F7FF; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h38AFDF7FFFFFFFFF; - ans = 64'hC00000000000F7FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4861037\n"); - end - xrf = 64'hC000000000000001; - y = 64'h7D4538A05A3C0F60; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFF562; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4861651\n"); - end - xrf = 64'h8020004000000010; - y = 64'hBEF00007FFDFFFFF; - zrf = 64'hE39FFFFFFFEFF7FF; - ans = 64'hE39FFFFFFFEFF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4862265\n"); - end - xrf = 64'hC000000000000001; - y = 64'hBFD0000000000001; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4862879\n"); - end - xrf = 64'h41400000FFF80000; - y = 64'hBFDFFF7F7FFFFFFF; - zrf = 64'hC000000000000000; - ans = 64'hC12FFF857FE7F83F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4863493\n"); - end - xrf = 64'hC000000000000001; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'hBFBFFDFFFFFFFFFF; - ans = 64'h3FEC004000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4864107\n"); - end - xrf = 64'h000FFFFFFFFBBFFF; - y = 64'hC5D0040000004000; - zrf = 64'hC019BF24778DB6DA; - ans = 64'hC019BF24778DB6DA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4864721\n"); - end - xrf = 64'h5F6FFDFF80000000; - y = 64'hBFE0000000000001; - zrf = 64'h3CA0000000000000; - ans = 64'hDF5FFDFF80000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4865335\n"); - end - xrf = 64'hC000000000000001; - y = 64'h46EFF3369AD1D373; - zrf = 64'hC110000007FFFDFF; - ans = 64'hC6FFF3369AD1D375; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4865949\n"); - end - xrf = 64'h40CFFFFE00000000; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hC05F000000000004; - ans = 64'hC0D01EFF00000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4866563\n"); - end - xrf = 64'hC000000000000001; - y = 64'h41DFE029B1F4EF77; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4867177\n"); - end - xrf = 64'hC7EFC00003FFFFFE; - y = 64'hC210006000000000; - zrf = 64'h43E622D779BD8B5E; - ans = 64'h4A0FC0BE840017FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4867791\n"); - end - xrf = 64'hC000000000000001; - y = 64'hBFF0000000000000; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4868405\n"); - end - xrf = 64'hB81FFBFFFFFFFBFF; - y = 64'hBFD00FFFFFFFFFEF; - zrf = 64'hBFF0000000000001; + z = 64'hBFF0000000000001; ans = 64'hBFF0000000000001; rn = 1; rz = 0; @@ -372721,19 +103503,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -372749,12 +103531,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4869019\n"); + $fwrite(fp,"4434827\n"); end - xrf = 64'hC000000000000001; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h0F8001000007FFFF; - ans = 64'h4010000000000000; + x = 64'h47E0000000000FFE; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h54764316901F286C; + ans = 64'h54764316901F286C; rn = 1; rz = 0; rm = 0; @@ -372768,19 +103550,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -372796,12 +103578,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4869633\n"); + $fwrite(fp,"4436841\n"); end - xrf = 64'h4007FFFFFFFBFFFE; - y = 64'hBFBFFFFFFF1FFFFF; - zrf = 64'h3810000000040010; - ans = 64'hBFD7FFFFFF53FFFD; + x = 64'hC3FEA8421E763A73; + y = 64'hC02FFFFF88000000; + z = 64'h403FFFF8FFFFFFFF; + ans = 64'h443EA841AB7F4281; rn = 1; rz = 0; rm = 0; @@ -372815,19 +103597,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -372843,12 +103625,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4870247\n"); + $fwrite(fp,"4438855\n"); end - xrf = 64'hA19C000000010000; - y = 64'hC000000000000000; - zrf = 64'h0010000000000001; - ans = 64'h21AC000000010000; + x = 64'hBFEFFFFFFFFFFFFE; + y = 64'hBFE0000000000000; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; rn = 1; rz = 0; rm = 0; @@ -372862,19 +103644,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -372890,12 +103672,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4870861\n"); + $fwrite(fp,"4440869\n"); end - xrf = 64'hC000000000000001; - y = 64'hBFEA5262A26A1F13; - zrf = 64'h22D004007FFFFFFE; - ans = 64'h3FFA5262A26A1F15; + x = 64'h4032FFFFFFFFFFFE; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h3FEFFFBFFFFFBFFF; + ans = 64'hC0320002000001FD; rn = 1; rz = 0; rm = 0; @@ -372909,19 +103691,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -372937,12 +103719,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4871475\n"); + $fwrite(fp,"4442883\n"); end - xrf = 64'h41C7FFFFFFFFFFEF; - y = 64'hC000000000000001; - zrf = 64'h4D5B36A4936D40E0; - ans = 64'h4D5B36A4936D40E0; + x = 64'h380FFFFDFEFFFFFE; + y = 64'hC47F7FFFFFFFFFF7; + z = 64'hB7FFFFFF80003FFF; + ans = 64'hBC9F7FFE0703FFF5; rn = 1; rz = 0; rm = 0; @@ -372956,19 +103738,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -372984,716 +103766,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4872089\n"); + $fwrite(fp,"4444897\n"); end - xrf = 64'hC000000000000001; - y = 64'hBFD0000001000100; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4872703\n"); - end - xrf = 64'h434000001000001F; - y = 64'hC1DFFFFFFFFFFC1E; - zrf = 64'h2080000002000004; - ans = 64'hC53000000FFFFE2E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4873317\n"); - end - xrf = 64'hC000000000000001; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4873931\n"); - end - xrf = 64'hC030000000100200; - y = 64'h0000000000000020; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4874545\n"); - end - xrf = 64'hC000000000000001; - y = 64'hC010000000000001; - zrf = 64'h37E9490162396B5D; - ans = 64'h4020000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4875159\n"); - end - xrf = 64'hBFFFFFFFFFFE03FF; - y = 64'h480F7FFFFFFF7FFE; - zrf = 64'hC0AFFF8000000007; - ans = 64'hC81F7FFFFFFD8BED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4875773\n"); - end - xrf = 64'h3F7C62C8C8CC6DB4; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hBFAC62C8C8CC6DB2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4876387\n"); - end - xrf = 64'hC000000000000001; - y = 64'hB7FF77F31808A34C; - zrf = 64'h4020000080000003; - ans = 64'h4020000080000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4877001\n"); - end - xrf = 64'h31CFFFFFF7FFF800; - y = 64'hC340000000000000; - zrf = 64'h420AFCA0047D6412; - ans = 64'h420AFCA0047D6412; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4877615\n"); - end - xrf = 64'hC000000000000001; - y = 64'h37900000000801FE; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h401FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4878229\n"); - end - xrf = 64'hC0FFFF7FFFFFFBFE; - y = 64'h6FF0001400000000; - zrf = 64'h3DD0007FFFFFFFEF; - ans = 64'hF0FFFFA7FF5FFBFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4878843\n"); - end - xrf = 64'hC000000000000001; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'h4350000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4879457\n"); - end - xrf = 64'hC3BF7FFFFFFFFDFF; - y = 64'hBFE00103FFFFFFFE; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'h43AF81FFDFFFFDFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4880071\n"); - end - xrf = 64'hC000000000000001; - y = 64'hFFE0000000000000; - zrf = 64'h44704000000000FE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4880685\n"); - end - xrf = 64'hC315276BA6026623; - y = 64'h405E001000000000; - zrf = 64'h2D507FFFFEFFFFFE; - ans = 64'hC383D4FF7F5812C2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4881299\n"); - end - xrf = 64'hC1E000000000EFFE; - y = 64'hFFE0000000000001; - zrf = 64'hFFFFFFFFFFFFFFFE; + x = 64'hBFEFFFFFFFFFFFFE; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -373708,19 +103785,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -373736,12 +103813,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4881913\n"); + $fwrite(fp,"4446911\n"); end - xrf = 64'hC000000000000001; - y = 64'h0022957BDB5C2F4F; - zrf = 64'h8F40000000006FFE; - ans = 64'h8F40000000006FFE; + x = 64'h3E7491C102F637FB; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h401FFFFE000007FF; + ans = 64'h401FFFFDEB6E46FC; rn = 1; rz = 0; rm = 0; @@ -373755,19 +103832,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -373783,12 +103860,200 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4882527\n"); + $fwrite(fp,"4448925\n"); end - xrf = 64'h3ADFFFFFBFEFFFFF; + x = 64'hC17614B22E982158; + y = 64'hC3C001FFFFFFDFFE; + z = 64'hBEB0001FFFFFFEFF; + ans = 64'h45461774C4DDC830; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4450939\n"); + end + x = 64'hBFEFFFFFFFFFFFFE; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h401FFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4452953\n"); + end + x = 64'h3F6F814B1821DEBD; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hB80FFEFFFFBFFFFF; + ans = 64'hC2CF814B1821DEBC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4454967\n"); + end + x = 64'h9B0007FFEFFFFFFE; + y = 64'h000E000001FFFFFE; + z = 64'h3810000000FF8000; + ans = 64'h3810000000FF8000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4456981\n"); + end + x = 64'hBFEFFFFFFFFFFFFE; y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h3A700000001FFFFE; - ans = 64'hFADFFFFFBFEFFFFD; + z = 64'h3FF0000000000001; + ans = 64'h7FEFFFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -373802,19 +104067,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -373830,105 +104095,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4883141\n"); + $fwrite(fp,"4458995\n"); end - xrf = 64'hC000000000000001; - y = 64'hBFBE01FFFFFFFFFE; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h4010F00FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4883755\n"); - end - xrf = 64'h3EB000001FF7FFFE; - y = 64'h3F2FFC0000000002; - zrf = 64'h4020001FE0000000; - ans = 64'h4020001FE001FFC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4884369\n"); - end - xrf = 64'hC000000000000001; + x = 64'hDD53FDFFFFFFFFFF; y = 64'hFFF0000000000001; - zrf = 64'hC01FFFFFFFFFFFFE; + z = 64'h41F0003FF0000000; ans = 64'hFFF8000000000001; rn = 1; rz = 0; @@ -373943,19 +104114,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -373971,12 +104142,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4884983\n"); + $fwrite(fp,"4461009\n"); end - xrf = 64'hC03A3920286F74D0; - y = 64'hC03FFFFFFFFE003E; - zrf = 64'hBFD0000000000000; - ans = 64'h408A3720286DD171; + x = 64'hC01FFFFFFFC0000F; + y = 64'h4800000000FF7FFE; + z = 64'h380FFFFFFFFE00FE; + ans = 64'hC830000000DF8005; rn = 1; rz = 0; rm = 0; @@ -373990,19 +104161,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -374018,11 +104189,716 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4885597\n"); + $fwrite(fp,"4463023\n"); end - xrf = 64'hC000000000000001; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'hC3DF0000000001FE; + x = 64'hBFF0000000000000; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4465037\n"); + end + x = 64'h023FFFF000FFFFFE; + y = 64'h0010000000000001; + z = 64'h480FFFFFFFFFFF88; + ans = 64'h480FFFFFFFFFFF88; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4467051\n"); + end + x = 64'hC7F0000000007EFF; + y = 64'hBA5001F800000000; + z = 64'h41CFFFFFFFFFFFEB; + ans = 64'h425011F800007F0F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4469065\n"); + end + x = 64'hBFF0000000000000; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4471079\n"); + end + x = 64'h3FD0040000000FFF; + y = 64'h3FD0000000000001; + z = 64'h381FFFFFFFFFFFAF; + ans = 64'h3FB0040000001000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4473093\n"); + end + x = 64'hC1D0000020080000; + y = 64'h4072EBBC8A7E099C; + z = 64'hB800FDFFFFFFFFFE; + ans = 64'hC252EBBCB05EF88F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4475107\n"); + end + x = 64'hBFF0000000000000; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hBFEFFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4477121\n"); + end + x = 64'hC7F00003FFFBFFFE; + y = 64'h3FF0000000000000; + z = 64'h4C00000000000004; + ans = 64'h4C00000000000004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4479135\n"); + end + x = 64'h41FFFFFFFFFFF020; + y = 64'hB81F807FFFFFFFFE; + z = 64'h401FFFFFFDFFFC00; + ans = 64'h401FFFFFFDFFFC00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4481149\n"); + end + x = 64'hBFF0000000000000; + y = 64'h4000000000000001; + z = 64'hBFF0000000000001; + ans = 64'hC008000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4483163\n"); + end + x = 64'h3FE0800007FFFFFF; + y = 64'h4010000000000000; + z = 64'h352000003FFFFFFC; + ans = 64'h4000800007FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4485177\n"); + end + x = 64'h40057F9AD8C03509; + y = 64'hBFCFFFFF00007FFF; + z = 64'h3FEFC0FFFFFFFFFF; + ans = 64'h3FD482CBA678977D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4487191\n"); + end + x = 64'hBFF0000000000000; + y = 64'h4340000000000001; + z = 64'h4340000000000000; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4489205\n"); + end + x = 64'h87DFFFFFFFF81FFF; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h3B57637B7C305FA0; + ans = 64'h3B57637B7C305FA0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4491219\n"); + end + x = 64'h37E00000077FFFFF; + y = 64'hBCACCF6DD7D97B4E; + z = 64'hC130009FFFFFFFFF; + ans = 64'hC130009FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4493233\n"); + end + x = 64'hBFF0000000000000; + y = 64'h7FF0000000000000; + z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -374037,19 +104913,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -374065,12 +104941,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4886211\n"); + $fwrite(fp,"4495247\n"); end - xrf = 64'h43DFC3FFFFFFFFFF; - y = 64'h3F20000000000800; - zrf = 64'hDF000000000001BE; - ans = 64'hDF000000000001BE; + x = 64'h3E0FFFFC000003FF; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hBF1FFFFF80000000; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -374084,19 +104960,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -374112,12 +104988,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4886825\n"); + $fwrite(fp,"4497261\n"); end - xrf = 64'hFFDFFC0400000000; - y = 64'h0000000000000000; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; + x = 64'hC3E29C257CEEF008; + y = 64'h3FCFFFFFFEFF7FFF; + z = 64'h3FC81A16A0AEB127; + ans = 64'hC3C29C257C59C46B; rn = 1; rz = 0; rm = 0; @@ -374131,19 +105007,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -374159,2737 +105035,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4887439\n"); + $fwrite(fp,"4499275\n"); end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h7FFFFFFFFDFF7FFE; - zrf = 64'h3810000FFFFFFEFE; - ans = 64'h7FFFFFFFFDFF7FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4888053\n"); - end - xrf = 64'hC0800000007F7FFE; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'hC3FFFD7FFFFFFFFE; - ans = 64'hC3FFFD7FFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4888667\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h404FFFF7FFFFFFF6; - zrf = 64'h4000000000000000; - ans = 64'hC06FBFF7FFFFFFF5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4889281\n"); - end - xrf = 64'h800FFFFFFFE03FFF; - y = 64'h3EE6FAF707792158; - zrf = 64'hC0542823FB862163; - ans = 64'hC0542823FB862163; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4889895\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h0010000000000000; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4890509\n"); - end - xrf = 64'hBFFFFFFF7FFFFFEE; - y = 64'h37F000040007FFFF; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4891123\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hC3EBEA623B6EF908; - ans = 64'hC3EBEA623B6EF908; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4891737\n"); - end - xrf = 64'h7FE0100000007FFF; - y = 64'h434BAA36621D0319; - zrf = 64'hC0200FFFFFFFFFFD; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4892351\n"); - end - xrf = 64'hC03FFFFFFF800007; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4892965\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hC31F7FFFFFFFFFFE; - zrf = 64'h3DFDEC69FC753E7A; - ans = 64'h433F7FFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4893579\n"); - end - xrf = 64'h40500001FFFFF7FF; - y = 64'h3CA0000000000001; - zrf = 64'h457FFFFFFFFFFDFF; - ans = 64'h457FFFFFFFFFFDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4894193\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hE9335F7AD9330745; - zrf = 64'h3FF0000000000001; - ans = 64'h69535F7AD9330744; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4894807\n"); - end - xrf = 64'hBF9F00000000000E; - y = 64'hD52003F800000000; - zrf = 64'h3FB1FFE000000000; - ans = 64'h54CF07B08000000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4895421\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'hC000000000000001; - ans = 64'hC000000000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4896035\n"); - end - xrf = 64'h7FEFFFFFFFDF8000; - y = 64'h4015CABECC3008F3; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4896649\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h3FD0000000000001; - zrf = 64'hC02C1516E585CAB8; - ans = 64'hC02E1516E585CAB8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4897263\n"); - end - xrf = 64'h41CDFFFFFF7FFFFF; - y = 64'h326002000000007E; - zrf = 64'h3FD2000008000000; - ans = 64'h3FD2000008000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4897877\n"); - end - xrf = 64'h3FCF800000007FFF; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4898491\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hC124000000000FFF; - zrf = 64'h402C000000000200; - ans = 64'h4144000700000FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4899105\n"); - end - xrf = 64'hC79FFFFF80003FFE; - y = 64'h3FE0000000000000; - zrf = 64'hC39FF3FFFFFFFFFE; - ans = 64'hC78FFFFF80003FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4899719\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h3F40001FEFFFFFFF; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FEFEFFFE00FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4900333\n"); - end - xrf = 64'h42B76E2F7D763B70; - y = 64'h4C100103FFFFFFFE; - zrf = 64'h8020000FFFEFFFFE; - ans = 64'h4ED76FAC3BF9F22E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4900947\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hC017FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4901561\n"); - end - xrf = 64'h3ECEFFFFFFFFFFFD; - y = 64'h371FFFFFFFFFFF60; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h35FEFFFFFFFFFF62; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4902175\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h3FF0000000000000; - zrf = 64'h43CFFFFFEBFFFFFF; - ans = 64'h43CFFFFFEBFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4902789\n"); - end - xrf = 64'hC3CFFFFFE0FFFFFF; - y = 64'h381FFFC000000FFF; - zrf = 64'hFFD0800080000000; - ans = 64'hFFD0800080000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4903403\n"); - end - xrf = 64'hC1DFFFEFFFFFFFFE; - y = 64'h3FF0000000000001; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC1DFFFF002000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4904017\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hF940000202000000; - zrf = 64'hC007DBD1FFEF495A; - ans = 64'h7960000201FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4904631\n"); - end - xrf = 64'hC01CCABCDAFD206F; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hF9BFFFFFFFDFEFFF; - ans = 64'hF9BFFFFFFFDFEFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4905245\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hC5B00000001C0000; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h45D00000001BFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4905859\n"); - end - xrf = 64'h403DE383C827F5FE; - y = 64'h3CA47FFFFFFFFFFF; - zrf = 64'hC019595F64F83637; - ans = 64'hC019595F64F83632; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4906473\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h4000000000000001; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hC022000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4907087\n"); - end - xrf = 64'hC7EFFFBFFFFFFFBF; - y = 64'hC3C000FBFFFFFFFE; - zrf = 64'h8000000000000000; - ans = 64'h4BC000DBFE07FFDD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4907701\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h400FF7FFFFFBFFFF; - ans = 64'hC02802000000FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4908315\n"); - end - xrf = 64'hC00FFFF7FFF80000; - y = 64'hC00FBFFFFFBFFFFF; - zrf = 64'h4030000000010007; - ans = 64'h403FDFFC07DD080F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4908929\n"); - end - xrf = 64'h00100000000003F7; - y = 64'h4010000000000000; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4909543\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hBA90000000007FBF; - zrf = 64'hC01DB18B282F96F6; - ans = 64'hC01DB18B282F96F6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4910157\n"); - end - xrf = 64'h37EFFFFFFFFF3FFE; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hC7FFFFFFFFFFFFF8; - ans = 64'hC7FFFFFFFFFFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4910771\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h7FD5F9F699F78D14; - zrf = 64'h3FD0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4911385\n"); - end - xrf = 64'h3FE0100000000000; - y = 64'h7FF007FFFFFFF000; - zrf = 64'hBFBE4AB9C2ACF6C1; - ans = 64'h7FF807FFFFFFF000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4911999\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h4340000000000000; - zrf = 64'hBFE0000000000000; - ans = 64'hC35FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4912613\n"); - end - xrf = 64'h41E07FFFFFFFFFFC; - y = 64'hC2EFFFFFFFC00000; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4913227\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h3B3FFFFF000000FF; - ans = 64'hC36FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4913841\n"); - end - xrf = 64'hC34FF0000003FFFE; - y = 64'h3EAFFFFFFFC0003F; - zrf = 64'hC341000000007FFF; - ans = 64'hC3410001FF007FFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4914455\n"); - end - xrf = 64'h3FF000FFFFFFFBFF; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hC000000000000001; - ans = 64'h435000FFFFFFFBFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4915069\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hC840007FFFFF7FFF; - zrf = 64'h4030000000001FFD; - ans = 64'h4860007FFFFF7FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4915683\n"); - end - xrf = 64'h41C001FFF7FFFFFF; - y = 64'h7FE0000000000001; - zrf = 64'hBF9000003F000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4916297\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h43E87CFB9EFD49F1; - zrf = 64'h3CA0000000000001; - ans = 64'hC4087CFB9EFD49F0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4916911\n"); - end - xrf = 64'hC08FC000000003FF; - y = 64'h91BBFFFE00000000; - zrf = 64'h43FFC00000FFFFFF; - ans = 64'h43FFC00000FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4917525\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hBFD0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4918139\n"); - end - xrf = 64'h3FF0010000000003; - y = 64'hC4000000DFFFFFFE; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4918753\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h7FF0000000000001; - zrf = 64'h41F4CE025223114E; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4919367\n"); - end - xrf = 64'hC02FFFEFBFFFFFFF; - y = 64'hC1DF80000000FFFF; - zrf = 64'h002FFFFFFE004000; - ans = 64'h421F7FF00100FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4919981\n"); - end - xrf = 64'h8027FFFFFFFC0000; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4920595\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h801C1411314533C8; - zrf = 64'hC7EC000000003FFF; - ans = 64'hC7EC000000003FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4921209\n"); - end - xrf = 64'h3FB5945A760AC589; - y = 64'h8000000000000000; - zrf = 64'hC01FFFFFC00FFFFE; - ans = 64'hC01FFFFFC00FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4921823\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hC7E000003DFFFFFF; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h480000003DFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4922437\n"); - end - xrf = 64'hBFD00007FFEFFFFE; - y = 64'hC06F0001FFFFFFFF; - zrf = 64'h37E000000000407E; - ans = 64'h404F00117FE1FFF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4923051\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hBCAFFFFFFFFFFFFF; + x = 64'hBFF0000000000000; + y = 64'h8010000000000000; + z = 64'hBCAFFFFFFFFFFFFF; ans = 64'hBCAFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -376904,19 +105054,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -376932,11 +105082,528 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4923665\n"); + $fwrite(fp,"4501289\n"); end - xrf = 64'h0010000010007FFE; - y = 64'hBFDFFEEFFFFFFFFF; - zrf = 64'h434FFFFFFFFFFFFE; + x = 64'hC34FFFFF000FFFFF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h37F0000000403FFE; + ans = 64'h37F0000000403FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4503303\n"); + end + x = 64'hC1B000000FFFBFFF; + y = 64'hBCA01C44AB43B464; + z = 64'h456F2E37330BD0CF; + ans = 64'h456F2E37330BD0CF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4505317\n"); + end + x = 64'hBFF0000000000000; + y = 64'hBFD0000000000000; + z = 64'h3FF0000000000001; + ans = 64'h3FF4000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4507331\n"); + end + x = 64'h3FB0000001DFFFFF; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h40FFFFFFFFC10000; + ans = 64'h40FFFFFF7FC0FFF1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4509345\n"); + end + x = 64'hC00689BAC8335603; + y = 64'h4B700203FFFFFFFF; + z = 64'h47F000000000DFFE; + ans = 64'hCB868C91A1FB0E79; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4511359\n"); + end + x = 64'hBFF0000000000000; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'hC33FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4513373\n"); + end + x = 64'hBCA3B1086BF83C68; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hBFFFFFF000FFFFFF; + ans = 64'hBFFFFFF000FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4515387\n"); + end + x = 64'h40FFFFFBFC000000; + y = 64'h43EFFFEFFFFFFEFF; + z = 64'hC3E0000088000000; + ans = 64'h44FFFFE3FC01BCFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4517401\n"); + end + x = 64'hBFF0000000000000; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4519415\n"); + end + x = 64'hFFD91A9D576F11A5; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h25F8F363F18CAEF3; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4521429\n"); + end + x = 64'h3798007FFFFFFFFF; + y = 64'hC3D0000000008080; + z = 64'h0000200020000000; + ans = 64'hBB7800800000C0C3; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4523443\n"); + end + x = 64'hBFF0000000000000; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; ans = 64'h434FFFFFFFFFFFFE; rn = 1; rz = 0; @@ -376951,19 +105618,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -376979,12 +105646,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4924279\n"); + $fwrite(fp,"4525457\n"); end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h8010000000000000; - zrf = 64'h3CCFF80004000000; - ans = 64'h3CCFF80004000000; + x = 64'h7FD0000000001000; + y = 64'hFFE0000000000001; + z = 64'hC06E4CD1A7F9E48F; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -376998,19 +105665,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377026,12 +105693,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4924893\n"); + $fwrite(fp,"4527471\n"); end - xrf = 64'hC1CFE00000001FFF; - y = 64'hB8B00020000007FF; - zrf = 64'hC0200000000007FF; - ans = 64'hC0200000000007FF; + x = 64'h3FB7FFFFFFFFFFF6; + y = 64'h40200003FFFFFC00; + z = 64'hBF9000000FFFFFBE; + ans = 64'h3FE78005FF7FF9F8; rn = 1; rz = 0; rm = 0; @@ -377045,19 +105712,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377073,12 +105740,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4925507\n"); + $fwrite(fp,"4529485\n"); end - xrf = 64'h800FFFFFFBFFFFFE; - y = 64'h8010000000000001; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hBFEFFFFFFFFFFFFE; + x = 64'hBFF0000000000000; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hFFFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -377092,19 +105759,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377120,12 +105787,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4926121\n"); + $fwrite(fp,"4531499\n"); end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hBFC19424BBDFE8F0; - zrf = 64'h7FF0040000000020; - ans = 64'h7FF8040000000020; + x = 64'hC34FDFFFFFFBFFFF; + y = 64'h0000000000000001; + z = 64'h00000007FBFFFFFF; + ans = 64'h802FDFFC01FC0000; rn = 1; rz = 0; rm = 0; @@ -377139,19 +105806,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377167,12 +105834,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4926735\n"); + $fwrite(fp,"4533513\n"); end - xrf = 64'h7FDFFF0000020000; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h7FE00000003FFFFF; - ans = 64'h7FE00000003FFFFF; + x = 64'hBAA0004000000003; + y = 64'h3FCFEFFFFFFFFDFE; + z = 64'h41DFEFEFFFFFFFFE; + ans = 64'h41DFEFEFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -377186,19 +105853,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377214,12 +105881,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4927349\n"); + $fwrite(fp,"4535527\n"); end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hC0C00FFFFFBFFFFE; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h40E00FFFFFBFFFFD; + x = 64'hBFF0000000000001; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; rn = 1; rz = 0; rm = 0; @@ -377233,19 +105900,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377261,12 +105928,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4927963\n"); + $fwrite(fp,"4537541\n"); end - xrf = 64'h41CFFF000000001E; - y = 64'h3BAD83C2E54B064B; - zrf = 64'hC807FFFFF7FFFFFE; - ans = 64'hC807FFFFF7FFFFFE; + x = 64'h000FFFFDFFFFFBFE; + y = 64'h3CA0000000000000; + z = 64'hD0D0000004000000; + ans = 64'hD0D0000004000000; rn = 1; rz = 0; rm = 0; @@ -377280,19 +105947,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377308,12 +105975,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4928577\n"); + $fwrite(fp,"4539555\n"); end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hBCA0000000000001; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h3CC0000000000000; + x = 64'hFFD00FFFFFFFFFFC; + y = 64'hC0DA4296FEAC7D13; + z = 64'h3FD0200000000003; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -377327,19 +105994,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377355,12 +106022,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4929191\n"); + $fwrite(fp,"4541569\n"); end - xrf = 64'h5D69D361B8CEDAEA; - y = 64'h43FFFFFFFFFFFFFD; - zrf = 64'h4340000000000000; - ans = 64'h6179D361B8CEDAE8; + x = 64'hBFF0000000000001; + y = 64'h3FD0000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -377374,19 +106041,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377402,12 +106069,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4929805\n"); + $fwrite(fp,"4543583\n"); end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h800FFFFBFFDFFFFF; - ans = 64'h3CCFFFFFFFFFFFFD; + x = 64'hC3FFFFFFFFFFFB80; + y = 64'h3FE0000000000000; + z = 64'hC3EFFFFFFFFF9FFE; + ans = 64'hC3FFFFFFFFFFCDBF; rn = 1; rz = 0; rm = 0; @@ -377421,19 +106088,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377449,12 +106116,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4930419\n"); + $fwrite(fp,"4545597\n"); end - xrf = 64'hC3DFFFF000000200; - y = 64'h37F00000000400FF; - zrf = 64'h37E000000000005F; - ans = 64'hBBDFFFF0000803FA; + x = 64'h43D35995D8DCF194; + y = 64'h320FFFFFFE000006; + z = 64'h404FDFFFFFFFFEFE; + ans = 64'h404FDFFFFFFFFEFE; rn = 1; rz = 0; rm = 0; @@ -377468,19 +106135,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377496,12 +106163,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4931033\n"); + $fwrite(fp,"4547611\n"); end - xrf = 64'hB7F20000000FFFFF; - y = 64'hBFD0000000000000; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE0000000000000; + x = 64'hBFF0000000000001; + y = 64'h3FF0000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBFF0000000000003; rn = 1; rz = 0; rm = 0; @@ -377515,19 +106182,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377543,12 +106210,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4931647\n"); + $fwrite(fp,"4549625\n"); end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hC020000000FFFFFF; - zrf = 64'hC018F1601E2EEA56; - ans = 64'h4039C3A7FA744567; + x = 64'h2FAFFFFBFBFFFFFF; + y = 64'h4000000000000000; + z = 64'hC0300000000EFFFE; + ans = 64'hC0300000000EFFFE; rn = 1; rz = 0; rm = 0; @@ -377562,19 +106229,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377590,12 +106257,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4932261\n"); + $fwrite(fp,"4551639\n"); end - xrf = 64'h7FD4000000003FFF; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h4010000000020FFF; - ans = 64'hFFC4000000003FFE; + x = 64'hEADFF7035B159F4C; + y = 64'hC00BFFFFFFFFBFFF; + z = 64'hCBF00020000003FF; + ans = 64'h6AFBF822EFB2AB73; rn = 1; rz = 0; rm = 0; @@ -377609,19 +106276,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377637,12 +106304,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4932875\n"); + $fwrite(fp,"4553653\n"); end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h406FE00001000000; - zrf = 64'h0000000000000000; - ans = 64'hC08FE00000FFFFFF; + x = 64'hBFF0000000000001; + y = 64'h4010000000000001; + z = 64'h3FF0000000000001; + ans = 64'hC008000000000004; rn = 1; rz = 0; rm = 0; @@ -377656,19 +106323,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377684,12 +106351,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4933489\n"); + $fwrite(fp,"4555667\n"); end - xrf = 64'h402FFFC0000001FF; - y = 64'hBFE002001FFFFFFF; - zrf = 64'h0E52EB4C83CFA9CF; - ans = 64'hC02001E01BFFC0FF; + x = 64'hBCA926B08C93F8CE; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hC01FFF7FFF7FFFFF; + ans = 64'hC01FFF7FFF800001; rn = 1; rz = 0; rm = 0; @@ -377703,19 +106370,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377731,12 +106398,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4934103\n"); + $fwrite(fp,"4557681\n"); end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hBFE0000000000000; - zrf = 64'h8010000000000000; - ans = 64'h3FFFFFFFFFFFFFFF; + x = 64'hC02001FFFDFFFFFF; + y = 64'h3FE00000800FFFFF; + z = 64'hC02F5B9B276E56D7; + ans = 64'hC033AE4DB33F2BE7; rn = 1; rz = 0; rm = 0; @@ -377750,19 +106417,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377778,12 +106445,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4934717\n"); + $fwrite(fp,"4559695\n"); end - xrf = 64'h9BAFF7FFFC000000; - y = 64'h8EE07FFFFFFFFFF6; - zrf = 64'h4010000000000001; - ans = 64'h4010000000000001; + x = 64'hBFF0000000000001; + y = 64'h7FE0000000000000; + z = 64'hC340000000000000; + ans = 64'hFFE0000000000001; rn = 1; rz = 0; rm = 0; @@ -377797,19 +106464,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377825,12 +106492,435 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4935331\n"); + $fwrite(fp,"4561709\n"); end - xrf = 64'hC00FFFFFFFFFFFFF; + x = 64'hCC3FFFE00001FFFF; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h41FFFFFFFBFFDFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4563723\n"); + end + x = 64'h37EE7CD50F3001A6; + y = 64'hC02FFFFFFFFC000F; + z = 64'h8020000040000010; + ans = 64'hB82E7CD50F2C321A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4565737\n"); + end + x = 64'hBFF0000000000001; + y = 64'h8000000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4567751\n"); + end + x = 64'hC02002FFFFFFFFFE; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hA2400000001FFBFF; + ans = 64'hA2400000001FFBFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4569765\n"); + end + x = 64'h410FFFFFFFC07FFF; + y = 64'h3800000000009FFE; + z = 64'hC03FFFFB00000000; + ans = 64'hC03FFFFB00000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4571779\n"); + end + x = 64'hBFF0000000000001; + y = 64'hBCA0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CB8000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4573793\n"); + end + x = 64'hBFF8E19F4056F6DE; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h8015EF2373E6512B; + ans = 64'h3CB8E19F4056F6DD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4575807\n"); + end + x = 64'hC3C86555AE0CF8FE; + y = 64'hBCA59E810275F37D; + z = 64'h3D7152CDF414B4CE; + ans = 64'h40807B56EBA58A9E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4577821\n"); + end + x = 64'hBFF0000000000001; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hBFE0000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4579835\n"); + end + x = 64'h7FD00080000FFFFE; y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hBFFE000000000020; - ans = 64'h4000FFFFFFFFFFEE; + z = 64'hC8D001FFFFFFDFFE; + ans = 64'hFFD00080000FFFFD; rn = 1; rz = 0; rm = 0; @@ -377844,19 +106934,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377872,12 +106962,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4935945\n"); + $fwrite(fp,"4581849\n"); end - xrf = 64'h3CA0007E00000000; - y = 64'hBFC111993E9ED5B8; - zrf = 64'hBCAE8EE974ED1ABE; - ans = 64'hBCB05896B509E78D; + x = 64'hB7FFFFFFFFFF9FFF; + y = 64'h3FC3853BC130E493; + z = 64'hB1500007FFFFFDFE; + ans = 64'hB7D3853BC130AA03; rn = 1; rz = 0; rm = 0; @@ -377891,19 +106981,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377919,12 +107009,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4936559\n"); + $fwrite(fp,"4583863\n"); end - xrf = 64'hBFFC0EF65D9D8DB0; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hBFD0000000000001; - ans = 64'h3FF80EF65D9D8DAE; + x = 64'hBFF0000000000001; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h4340000000000001; rn = 1; rz = 0; rm = 0; @@ -377938,19 +107028,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -377966,12 +107056,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4937173\n"); + $fwrite(fp,"4585877\n"); end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hC1E5D61B1ADC38B0; - zrf = 64'hA7E03FFFDFFFFFFF; - ans = 64'h4205D61B1ADC38AF; + x = 64'h43FFFFFFFFFFC3FE; + y = 64'hC000000000000001; + z = 64'hC0A01869BC9AEAD1; + ans = 64'hC40FFFFFFFFFC400; rn = 1; rz = 0; rm = 0; @@ -377985,19 +107075,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -378013,12 +107103,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4937787\n"); + $fwrite(fp,"4587891\n"); end - xrf = 64'h46BBF9DB4AE5DB5E; - y = 64'hBFF0000000000001; - zrf = 64'hC0011F9814CF0C8A; - ans = 64'hC6BBF9DB4AE5DB60; + x = 64'hBAE000FFFFFFFFFA; + y = 64'hBFC000000011FFFF; + z = 64'h429FBFFFFFFFFFFF; + ans = 64'h429FBFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -378032,19 +107122,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -378060,11 +107150,199 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4938401\n"); + $fwrite(fp,"4589905\n"); end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h3FCF32DBCDBA7034; - zrf = 64'hFFF0000000000001; + x = 64'hBFF0000000000001; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4591919\n"); + end + x = 64'hBA0FFFFFFFFFFFFE; + y = 64'hC340000000000001; + z = 64'h207EC15F8069F3D2; + ans = 64'h3D60000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4593933\n"); + end + x = 64'h4340000200000001; + y = 64'h3FFFFFFFFFFFC0FF; + z = 64'h333EBFFFFFFFFFFF; + ans = 64'h43500001FFFFE080; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4595947\n"); + end + x = 64'hBFF0000000000001; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4597961\n"); + end + x = 64'h8001800000000000; + y = 64'hFFF0000000000001; + z = 64'h4EC8E95F80481629; ans = 64'hFFF8000000000001; rn = 1; rz = 0; @@ -378079,19 +107357,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -378107,12 +107385,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4939015\n"); + $fwrite(fp,"4599975\n"); end - xrf = 64'h8013097B4AB9C85F; - y = 64'h2C73FFFFFFFFFFFD; - zrf = 64'h3FFB6D3C6646C251; - ans = 64'h3FFB6D3C6646C251; + x = 64'h290FFFFF0001FFFE; + y = 64'hA330007FFFFFFFF8; + z = 64'h7FFEFFFFFFFFFFEF; + ans = 64'h7FFEFFFFFFFFFFEF; rn = 1; rz = 0; rm = 0; @@ -378126,19 +107404,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -378154,12 +107432,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4939629\n"); + $fwrite(fp,"4601989\n"); end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h8000000000000001; - ans = 64'h401FFFFFFFFFFFFD; + x = 64'hBFFFFFFFFFFFFFFF; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; rn = 1; rz = 0; rm = 0; @@ -378173,19 +107451,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -378201,12 +107479,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4940243\n"); + $fwrite(fp,"4604003\n"); end - xrf = 64'hC0DFBFFFFFFFFFDE; - y = 64'h8019C6D859BEEBC9; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h400FFFFFFFFFFFFF; + x = 64'h802FFEFFFFEFFFFF; + y = 64'h0010000000000000; + z = 64'hB11FFFFFE0000100; + ans = 64'hB11FFFFFE0000100; rn = 1; rz = 0; rm = 0; @@ -378220,19 +107498,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -378248,12 +107526,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4940857\n"); + $fwrite(fp,"4606017\n"); end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hC000000000000001; - zrf = 64'h37F2C5CFF18ADD7D; - ans = 64'h4020000000000000; + x = 64'hC06905FEBB773604; + y = 64'hC022A0C0B2A5AE70; + z = 64'h3FE47DD1C6D2DE46; + ans = 64'h409D24B79FC8395C; rn = 1; rz = 0; rm = 0; @@ -378267,19 +107545,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -378295,12 +107573,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4941471\n"); + $fwrite(fp,"4608031\n"); end - xrf = 64'hC340000040001FFE; - y = 64'h44D211D760B4F9E1; - zrf = 64'hAB8DFFFFFFFE0000; - ans = 64'hC82211D7A8FC7B85; + x = 64'hBFFFFFFFFFFFFFFF; + y = 64'h3CA0000000000001; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; rn = 1; rz = 0; rm = 0; @@ -378314,19 +107592,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -378342,12 +107620,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4942085\n"); + $fwrite(fp,"4610045\n"); end - xrf = 64'h400FFFFFFEFFFFBF; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hC02FFFFFFEFFFFBE; + x = 64'hC01E25FD8C379C63; + y = 64'h3FD0000000000000; + z = 64'hDAE00000FFFBFFFF; + ans = 64'hDAE00000FFFBFFFF; rn = 1; rz = 0; rm = 0; @@ -378361,19 +107639,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -378389,12 +107667,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4942699\n"); + $fwrite(fp,"4612059\n"); end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hB0B45223C29CCAC2; - zrf = 64'h4021000000004000; - ans = 64'h4021000000004000; + x = 64'h7FDFFFFFFFFFFF3E; + y = 64'h3FD1B85566F6674C; + z = 64'hC03FFFFFFFFFFC02; + ans = 64'h7FC1B85566F666E1; rn = 1; rz = 0; rm = 0; @@ -378408,19 +107686,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -378436,12 +107714,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4943313\n"); + $fwrite(fp,"4614073\n"); end - xrf = 64'hC7E0000003FFFFFF; - y = 64'hC010000000000000; - zrf = 64'h395000001FFFC000; - ans = 64'h4800000003FFFFFF; + x = 64'hBFFFFFFFFFFFFFFF; + y = 64'h3FE0000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -378455,19 +107733,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -378483,12 +107761,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4943927\n"); + $fwrite(fp,"4616087\n"); end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hCCC0000000003FFE; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; + x = 64'h3CA000200FFFFFFF; + y = 64'h3FF0000000000000; + z = 64'h7FDEE2B9E7B53CAD; + ans = 64'h7FDEE2B9E7B53CAD; rn = 1; rz = 0; rm = 0; @@ -378502,19 +107780,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -378530,12 +107808,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4944541\n"); + $fwrite(fp,"4618101\n"); end - xrf = 64'h3FB0FFFFFFFFF7FF; - y = 64'h4060008000007FFF; - zrf = 64'hE4DFFFFFFF7FF7FE; - ans = 64'hE4DFFFFFFF7FF7FE; + x = 64'h404FFFF81FFFFFFF; + y = 64'h3EB6DBCBFD738A28; + z = 64'h7E244708F1E8F80F; + ans = 64'h7E244708F1E8F80F; rn = 1; rz = 0; rm = 0; @@ -378549,19 +107827,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -378577,11 +107855,340 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4945155\n"); + $fwrite(fp,"4620115\n"); end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h7FFFFFFFFFFFFFFF; + x = 64'hBFFFFFFFFFFFFFFF; + y = 64'h4000000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hC010000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4622129\n"); + end + x = 64'h5AFFFFFFFFBF7FFE; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h7FDFFFFEFFFFF7FE; + ans = 64'h7FDFFFFEFFFFF7FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4624143\n"); + end + x = 64'h4030000800004000; + y = 64'hC34FFFFFFFFC3FFF; + z = 64'hE8EFFFFFFFFFF807; + ans = 64'hE8EFFFFFFFFFF807; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4626157\n"); + end + x = 64'hBFFFFFFFFFFFFFFF; + y = 64'h4340000000000000; + z = 64'hBFF0000000000001; + ans = 64'hC350000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4628171\n"); + end + x = 64'hC74007FFFFFFFFF7; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hC3E0100000002000; + ans = 64'hCAA007FFFFFFFFF6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4630185\n"); + end + x = 64'h38000000FFFFFFFD; + y = 64'hB81FFFF7FFF7FFFE; + z = 64'h41E1DCADEE9FBD6B; + ans = 64'h41E1DCADEE9FBD6B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4632199\n"); + end + x = 64'hBFFFFFFFFFFFFFFF; + y = 64'h7FF0000000000000; + z = 64'h4340000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4634213\n"); + end + x = 64'h400FFFFFFFFFF7DF; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hF378000003FFFFFF; ans = 64'h7FFFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -378596,19 +108203,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -378624,11 +108231,3583 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4945769\n"); + $fwrite(fp,"4636227\n"); end - xrf = 64'hBCAFFDFFFFFFF800; - y = 64'hBFDC000000001FFF; - zrf = 64'h3FFFFFFFFFFFFFFE; + x = 64'h3F4FFFFDFFFFFFBF; + y = 64'hB5FC7E17D9EAF931; + z = 64'hBDAFFFFFFFF800FF; + ans = 64'hBDAFFFFFFFF800FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4638241\n"); + end + x = 64'hBFFFFFFFFFFFFFFF; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4640255\n"); + end + x = 64'h402FFFE000007FFF; + y = 64'h801FFFFFFFFFFFFF; + z = 64'h401FFFF07FFFFFFF; + ans = 64'h401FFFF07FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4642269\n"); + end + x = 64'hC01FC00003FFFFFF; + y = 64'hDE8FFFEFFFFF7FFF; + z = 64'hF91FFFFDFC000000; + ans = 64'hF91FFFFDFC000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4644283\n"); + end + x = 64'hBFFFFFFFFFFFFFFF; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4646297\n"); + end + x = 64'hBFFFFFFFFE0003FF; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h40031ADE702700A8; + ans = 64'h400B1ADE6FA701A8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4648311\n"); + end + x = 64'hA4DE62B77849478B; + y = 64'h3FC51C3A9DF592EF; + z = 64'hC80003FFFFFFFFF0; + ans = 64'hC80003FFFFFFFFF0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4650325\n"); + end + x = 64'hBFFFFFFFFFFFFFFF; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h4007FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4652339\n"); + end + x = 64'h41DFFFBFFDFFFFFF; + y = 64'hBFF0000000000001; + z = 64'hD5EFFFFFFFF81FFE; + ans = 64'hD5EFFFFFFFF81FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4654353\n"); + end + x = 64'h380D4729AE525911; + y = 64'h42EFFC00007FFFFE; + z = 64'h00210001FFFFFFFE; + ans = 64'h3B0D4380C991AB6B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4656367\n"); + end + x = 64'hBFFFFFFFFFFFFFFF; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC33FFFFFFFFFFFF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4658381\n"); + end + x = 64'h369F8000000003FF; + y = 64'hC010000000000001; + z = 64'hC07FFFFFFC0FFFFE; + ans = 64'hC07FFFFFFC0FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4660395\n"); + end + x = 64'hC003FFFFFFFFFF7F; + y = 64'hC0EFFFFFFFFFFF10; + z = 64'hB7EFFFFEFFFFDFFF; + ans = 64'h4103FFFFFFFFFEE9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4662409\n"); + end + x = 64'hBFFFFFFFFFFFFFFF; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4664423\n"); + end + x = 64'hC00FF80000FFFFFF; + y = 64'hFFE0000000000001; + z = 64'h3C2FFFFFFFFFC010; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4666437\n"); + end + x = 64'h41FFFBFEFFFFFFFF; + y = 64'hBFF0FBFFFFFFFFFF; + z = 64'h2F1FFE0000000007; + ans = 64'hC200F9DFF81FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4668451\n"); + end + x = 64'hBFFFFFFFFFFFFFFF; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4670465\n"); + end + x = 64'h37EFF635FC591D37; + y = 64'h0000000000000000; + z = 64'hC03DFFC000000000; + ans = 64'hC03DFFC000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4672479\n"); + end + x = 64'h40150F7B4D5E78B3; + y = 64'hC130000FFFBFFFFF; + z = 64'h43F55EF6C9431743; + ans = 64'h43F55EF6C94311FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4674493\n"); + end + x = 64'hBFFFFFFFFFFFFFFE; + y = 64'h0010000000000001; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4676507\n"); + end + x = 64'h3E9E07FFFFFFFFFF; + y = 64'h3CA0000000000000; + z = 64'hCAD387355AD2977C; + ans = 64'hCAD387355AD2977C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4678521\n"); + end + x = 64'h4082298B4297E5D7; + y = 64'h42F007FFFFFE0000; + z = 64'hBCAFFFFFFFFC0001; + ans = 64'h438232A00836EC99; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4680535\n"); + end + x = 64'hBFFFFFFFFFFFFFFE; + y = 64'h3FD0000000000001; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4682549\n"); + end + x = 64'h37EFFFFFFFFF0004; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h0003DFFFFFFFFFFF; + ans = 64'h37DFFFFFFFFF0002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4684563\n"); + end + x = 64'h7FFFFFFDFF7FFFFE; + y = 64'hC0000000001DFFFE; + z = 64'h434FFC0200000000; + ans = 64'h7FFFFFFDFF7FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4686577\n"); + end + x = 64'hBFFFFFFFFFFFFFFE; + y = 64'h3FF0000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4688591\n"); + end + x = 64'hB76E07014E0DD9FB; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hC1FFFBFFFFFFFFBF; + ans = 64'hC1FFFBFFFFFFFFBF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4690605\n"); + end + x = 64'hB80FFFFFF07FFFFF; + y = 64'hC027E00000000000; + z = 64'h3F50004000FFFFFF; + ans = 64'h3F50004000FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4692619\n"); + end + x = 64'hBFFFFFFFFFFFFFFE; + y = 64'h4010000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hC01FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4694633\n"); + end + x = 64'hBCA000100000001E; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hC030080000000100; + ans = 64'hC030080000000100; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4696647\n"); + end + x = 64'h000001000000007F; + y = 64'hC001FFFFFFFFF7FF; + z = 64'h00BFFFFFFFFFFFF7; + ans = 64'h00BFFFFF6FFFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4698661\n"); + end + x = 64'hBFFFFFFFFFFFFFFE; + y = 64'h7FE0000000000000; + z = 64'h3FF0000000000001; + ans = 64'hFFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4700675\n"); + end + x = 64'h802876727078CFD2; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'hC008E292C0AAE569; + ans = 64'hC02EAF1720A3892B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4702689\n"); + end + x = 64'hBEAFFFFFFEFFFFFD; + y = 64'h80200000200007FF; + z = 64'hC80003FFDFFFFFFE; + ans = 64'hC80003FFDFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4704703\n"); + end + x = 64'hBFFFFFFFFFFFFFFE; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4706717\n"); + end + x = 64'h3C3007FFBFFFFFFE; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h7FFFFFFFFE07FFFF; + ans = 64'h7FFFFFFFFE07FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4708731\n"); + end + x = 64'hBF07FFFFFFFFFFEF; + y = 64'hB7EDB746F5A5CDB3; + z = 64'h3AB5754CEFBE1F72; + ans = 64'h3AB5754CEFBE1F72; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4710745\n"); + end + x = 64'hBFFFFFFFFFFFFFFE; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4712759\n"); + end + x = 64'h3FBFFFFFFE000100; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hBF8FFFFFFFFD7FFF; + ans = 64'hBF8FFFFFFFFD800F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4714773\n"); + end + x = 64'h41EC0001FFFFFFFF; + y = 64'hC1F1EEA83E1F966A; + z = 64'h001BD6A7A40A5B07; + ans = 64'hC3EF61A8AA8C4EFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4716787\n"); + end + x = 64'hBFFFFFFFFFFFFFFE; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3FEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4718801\n"); + end + x = 64'hBFC000FFFBFFFFFF; + y = 64'hBFE0000000000001; + z = 64'hB7F0000000400010; + ans = 64'h3FB000FFFC000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4720815\n"); + end + x = 64'hBFDF00007FFFFFFF; + y = 64'h380FFFFFFFFF8000; + z = 64'h3FF385598F233ECE; + ans = 64'h3FF385598F233ECE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4722829\n"); + end + x = 64'hBFFFFFFFFFFFFFFE; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'h4007FFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4724843\n"); + end + x = 64'h400FFFFFFFFFFD7F; + y = 64'hC000000000000001; + z = 64'hC013FFFFFDFFFFFF; + ans = 64'hC029FFFFFEFFFEC0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4726857\n"); + end + x = 64'hBF8FFDFFFFFFFFFD; + y = 64'hC3FFFFFEFFFC0000; + z = 64'hA82003FFFFFEFFFF; + ans = 64'h439FFDFF000C003D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4728871\n"); + end + x = 64'hBFFFFFFFFFFFFFFE; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h4340000000000008; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4730885\n"); + end + x = 64'hBFD400000007FFFF; + y = 64'hC340000000000000; + z = 64'h4800060000000000; + ans = 64'h4800060000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4732899\n"); + end + x = 64'hDE00000000403FFF; + y = 64'h43E0000001EFFFFF; + z = 64'h40EFF80FFFFFFFFF; + ans = 64'hE1F0000002303FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4734913\n"); + end + x = 64'hBFFFFFFFFFFFFFFE; + y = 64'hFFE0000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4736927\n"); + end + x = 64'h801FFFFC00000000; + y = 64'hFFF0000000000000; + z = 64'h2300080000007FFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4738941\n"); + end + x = 64'hBCA0000000080FFF; + y = 64'hBFDEFFFFFFE00000; + z = 64'h403F7FFFFFFBFFFF; + ans = 64'h403F7FFFFFFBFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4740955\n"); + end + x = 64'hC000000000000000; + y = 64'h0000000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4742969\n"); + end + x = 64'hBDF82AE78C741692; + y = 64'h0010000000000000; + z = 64'hC84FFFFFFE000FFE; + ans = 64'hC84FFFFFFE000FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4744983\n"); + end + x = 64'hCA700003FFFDFFFF; + y = 64'hB806FFFFFFFFFFFF; + z = 64'hFFFFEFFEFFFFFFFF; + ans = 64'hFFFFEFFEFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4746997\n"); + end + x = 64'hC000000000000000; + y = 64'h3CA0000000000001; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4749011\n"); + end + x = 64'hBF83F15F996FACE6; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h3FB00FFFF8000000; + ans = 64'h3FB00FFFF8000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4751025\n"); + end + x = 64'hBFB00001FFFFFE00; + y = 64'h37EFFFFFFFBFFFFD; + z = 64'hC08FF80000000010; + ans = 64'hC08FF80000000010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4753039\n"); + end + x = 64'hC000000000000000; + y = 64'h3FE0000000000000; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4755053\n"); + end + x = 64'h400800001FFFFFFF; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h7FEFFFFFFFFF9FFF; + ans = 64'h7FEFFFFFFFFF9FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4757067\n"); + end + x = 64'h3801D02705E6F605; + y = 64'hFFD0008000000004; + z = 64'h43EF7FFFFFFFFFFE; + ans = 64'hF7E1D0B5871F2541; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4759081\n"); + end + x = 64'hC000000000000000; + y = 64'h4000000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4761095\n"); + end + x = 64'hB7FFFFFF07FFFFFF; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h43F0000100007FFF; + ans = 64'h43F0000100007FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4763109\n"); + end + x = 64'h436F8BB30527C3E1; + y = 64'hC3DFFF0000400000; + z = 64'hC5E000000FFFFFEF; + ans = 64'hC75F8AB6C7CEB229; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4765123\n"); + end + x = 64'hC000000000000000; + y = 64'h4340000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hC350000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4767137\n"); + end + x = 64'hB7FF36B99B086A9B; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hC1AF142D1ED4E9B1; + ans = 64'hC1AF142D1ED4E9B1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4769151\n"); + end + x = 64'h403FFB0000000000; + y = 64'h29BF3D5BEC0E2D80; + z = 64'hB7FFFFFFFFFDFFFF; + ans = 64'hB7FFFFFFFFFDFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4771165\n"); + end + x = 64'hC000000000000000; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4773179\n"); + end + x = 64'hC00FFFFFF8000001; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hB7FFDFF800000000; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4775193\n"); + end + x = 64'h3FE0000000000027; + y = 64'hBFFFFFFFFFFFFF77; + z = 64'h40600001FFFFDFFF; + ans = 64'h405FC003FFFFBFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4777207\n"); + end + x = 64'hC000000000000000; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4779221\n"); + end + x = 64'h7FE000001000003F; + y = 64'h8010000000000001; + z = 64'hC00040003FFFFFFF; + ans = 64'hC010200028000020; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4781235\n"); + end + x = 64'h433FC00004000000; + y = 64'hC7E0000000020010; + z = 64'hBFBFFFFFFEFFFEFF; + ans = 64'hCB2FC0000403F820; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4783249\n"); + end + x = 64'hC000000000000000; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4785263\n"); + end + x = 64'h001FFFFE0000007F; + y = 64'hBFD0000000000001; + z = 64'h3CA6780098C722B0; + ans = 64'h3CA6780098C722B0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4787277\n"); + end + x = 64'hD9F000003DFFFFFF; + y = 64'h41EFE007FFFFFFFF; + z = 64'hC0DFFFFFFFFFC1FF; + ans = 64'hDBEFE0087B841EFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4789291\n"); + end + x = 64'hC000000000000000; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; ans = 64'h3FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -378643,19 +111822,3638 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4791305\n"); + end + x = 64'hC00636536D8AD40E; + y = 64'hBFF0000000000001; + z = 64'h400F97076662A920; + ans = 64'h401AE6AD69F6BE98; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4793319\n"); + end + x = 64'h3FCFF3FFFFFFFFFF; + y = 64'h310000FFFF800000; + z = 64'h38100000800003FE; + ans = 64'h38100000800003FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4795333\n"); + end + x = 64'hC000000000000000; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'h4022000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4797347\n"); + end + x = 64'hC1CE00000000FFFF; + y = 64'hC010000000000000; + z = 64'h3CA001FFFFFFFEFE; + ans = 64'h41EE00000000FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4799361\n"); + end + x = 64'hC00000000000801F; + y = 64'hBFF000000FF7FFFF; + z = 64'hC1FFFFFE00000001; + ans = 64'hC1FFFFFDFFE00001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4801375\n"); + end + x = 64'hC000000000000000; + y = 64'hC340000000000001; + z = 64'hC340000000000000; + ans = 64'h4340000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4803389\n"); + end + x = 64'hAEFCE4D2B75F2241; + y = 64'hFFE0000000000000; + z = 64'hBCAFFFFFFFFF801F; + ans = 64'h6EECE4D2B75F2241; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4805403\n"); + end + x = 64'h3FB6726C7090ABFA; + y = 64'h001000000FFFFFE0; + z = 64'h40200000004003FF; + ans = 64'h40200000004003FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4807417\n"); + end + x = 64'hC000000000000000; + y = 64'hFFF0000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4809431\n"); + end + x = 64'h9EDFFFFFFEBFFFFF; + y = 64'h0000000000000000; + z = 64'h7FDFBC79F86CB8D2; + ans = 64'h7FDFBC79F86CB8D2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4811445\n"); + end + x = 64'h9F90040000001FFF; + y = 64'h8000FFE4B843FAAD; + z = 64'hB80FF7FFFFFE0000; + ans = 64'hB80FF7FFFFFE0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4813459\n"); + end + x = 64'hC000000000000001; + y = 64'h0010000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4815473\n"); + end + x = 64'h3FEF5A535F649EA9; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h3EF80CBAF04E7D23; + ans = 64'h3EF80CBAF04E7D23; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4817487\n"); + end + x = 64'hC8400007FFFFFFDE; + y = 64'h401FFFFFC0008000; + z = 64'h41F0000000000060; + ans = 64'hC8700007E0002FDE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4819501\n"); + end + x = 64'hC000000000000001; + y = 64'h3FD0000000000000; + z = 64'hBFF0000000000001; + ans = 64'hBFF8000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4821515\n"); + end + x = 64'h3FC080001FFFFFFF; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h3E60000400000007; + ans = 64'h3FB08000A0001FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4823529\n"); + end + x = 64'hC3CFFC00007FFFFF; + y = 64'h3C2BB996E37CCEFC; + z = 64'h769000000005FFFE; + ans = 64'h769000000005FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4825543\n"); + end + x = 64'hC000000000000001; + y = 64'h3FF0000000000000; + z = 64'h4340000000000000; + ans = 64'h433FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4827557\n"); + end + x = 64'h3FF003FFFFFDFFFF; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hFFFFFFFDFFFFFFFB; + ans = 64'hFFFFFFFDFFFFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4829571\n"); + end + x = 64'h0000000000000000; + y = 64'h41DFFFFFF807FFFE; + z = 64'h42100000003FFFDF; + ans = 64'h42100000003FFFDF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4831585\n"); + end + x = 64'hC000000000000001; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4833599\n"); + end + x = 64'h381905D4F9CFD211; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h47F01FFDFFFFFFFE; + ans = 64'h47F01FFDFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4835613\n"); + end + x = 64'hFFE00000001F8000; + y = 64'hC3CFFE0000008000; + z = 64'hC02007FFFFBFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4837627\n"); + end + x = 64'hC000000000000001; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hC360000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4839641\n"); + end + x = 64'hAEED32209391C748; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h41D63870E0F49A36; + ans = 64'hEEED32209391C747; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4841655\n"); + end + x = 64'h37EE6E74F86EAA00; + y = 64'h000FFFFFFE080000; + z = 64'hBFC0000000F80000; + ans = 64'hBFC0000000F80000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4843669\n"); + end + x = 64'hC000000000000001; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4845683\n"); + end + x = 64'hC00D7421886BB409; + y = 64'h8000000000000001; + z = 64'h43FFFFF000000008; + ans = 64'h43FFFFF000000008; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4847697\n"); + end + x = 64'h29984D3022BF3429; + y = 64'h000000000005FFFF; + z = 64'h322FFFBEFFFFFFFF; + ans = 64'h322FFFBEFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4849711\n"); + end + x = 64'hC000000000000001; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4851725\n"); + end + x = 64'hC0E1EAD1644C2360; + y = 64'hBCA0000000000001; + z = 64'hC3DFFFFFFFFE7FFF; + ans = 64'hC3DFFFFFFFFE7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4853739\n"); + end + x = 64'hBEA000002001FFFF; + y = 64'hC1CEF0DEA2CE737B; + z = 64'h400E000000000000; + ans = 64'h407F2CDEE0B40EDB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4855753\n"); + end + x = 64'hC000000000000001; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4857767\n"); + end + x = 64'hC3D0000001BFFFFF; + y = 64'hBFE0000000000001; + z = 64'h2140000000FFDFFF; + ans = 64'h43C0000001C00000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4859781\n"); + end + x = 64'h4DD40D9CD154CAEF; + y = 64'hF22FFF7FFFBFFFFF; + z = 64'hC03007FFFFDFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4861795\n"); + end + x = 64'hC000000000000001; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h4010000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4863809\n"); + end + x = 64'h3F30000020000000; + y = 64'hC000000000000000; + z = 64'hBFCFFFFFC001FFFF; + ans = 64'hBFD007FFE0110000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4865823\n"); + end + x = 64'h802FFFFFFFC001FE; + y = 64'hC1E123B4086EBB50; + z = 64'h3FB5797E09A179E2; + ans = 64'h3FB5797E09A179E2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4867837\n"); + end + x = 64'hC000000000000001; + y = 64'hC010000000000001; + z = 64'hBFF0000000000001; + ans = 64'h401C000000000004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4869851\n"); + end + x = 64'hB7FE380190D1E449; + y = 64'hC340000000000000; + z = 64'h3690200000010000; + ans = 64'h3B4E380190D1E449; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4871865\n"); + end + x = 64'h3E9FFFBFC0000000; + y = 64'h5072000080000000; + z = 64'hAE9FF8001FFFFFFF; + ans = 64'h4F21FFDC5BFEFF00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4873879\n"); + end + x = 64'hC000000000000001; + y = 64'hFFE0000000000001; + z = 64'h4340000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4875893\n"); + end + x = 64'hC05FFF8100000000; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'h419000000010FFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4877907\n"); + end + x = 64'hBF2EFFFFFFBFFFFF; + y = 64'h001A635FFEB94418; + z = 64'h3FF00100000001FE; + ans = 64'h3FF00100000001FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4879921\n"); + end + x = 64'hC00FFFFFFFFFFFFF; + y = 64'h0000000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4881935\n"); + end + x = 64'hC7FFFF0000001FFF; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h401B56E379B8AB6F; + ans = 64'h401B56E379B8AB6F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4883949\n"); + end + x = 64'hC1CFFFFFFFFFF6FF; + y = 64'h43CFFFFFFF7FFFF0; + z = 64'hC1CFFFFFFFFFFFE8; + ans = 64'hC5AFFFFFFF7FF6EF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4885963\n"); + end + x = 64'hC00FFFFFFFFFFFFF; + y = 64'h3CA0000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCC7FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4887977\n"); + end + x = 64'h37E3CAF180C9430E; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h3FDF22A7D23C7623; + ans = 64'h3FDF22A7D23C7623; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4889991\n"); + end + x = 64'hC31FEFF7FFFFFFFE; + y = 64'h407F14DABF153AF4; + z = 64'h43C9F50DA1A060A1; + ans = 64'h43C233BB7E80A07D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4892005\n"); + end + x = 64'hC00FFFFFFFFFFFFF; + y = 64'h3FE0000000000000; + z = 64'h3FF0000000000001; + ans = 64'hBFEFFFFFFFFFFFFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4894019\n"); + end + x = 64'hBFF080007FFFFFFF; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h41F0002003FFFFFF; + ans = 64'h41F0002003EF7FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4896033\n"); + end + x = 64'h000FFFFFEFFFDFFF; + y = 64'hC3E004FFFFFFFFFE; + z = 64'hBC3FFBFFFFFFFFF7; + ans = 64'hBC3FFBFFFFFFFFF7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4898047\n"); + end + x = 64'hC00FFFFFFFFFFFFF; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'hC340000000000004; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4900061\n"); + end + x = 64'h3FFFFFFF7FFFFFEF; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hE2F801FFFFFFFFFF; + ans = 64'hE2F801FFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4902075\n"); + end + x = 64'hC00FFFFFFDFFFFEE; + y = 64'hC028D9A8BEA71866; + z = 64'hCE2FFFFFFFFFFFC6; + ans = 64'hCE2FFFFFFFFFFFC6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4904089\n"); + end + x = 64'hC00FFFFFFFFFFFFF; + y = 64'h401FFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4906103\n"); + end + x = 64'h3EB7FFFFFFFFFFF0; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h3FC01FFFFFFFFFEF; + ans = 64'h42180000000080EF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4908117\n"); + end + x = 64'h434FFE0000000003; + y = 64'h3F050506FA43403E; + z = 64'hC036D0C0E5DF8B63; + ans = 64'h426503B6A9D0C1F4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4910131\n"); + end + x = 64'hC00FFFFFFFFFFFFF; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4912145\n"); + end + x = 64'hBFB000020003FFFE; + y = 64'h7FF0000000000001; + z = 64'h5510FFFFFFFF7FFE; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4914159\n"); + end + x = 64'hEB2000000000000D; + y = 64'hBCAFFFFFFFC0003F; + z = 64'h38E3FFFFFFFF7FFF; + ans = 64'h67DFFFFFFFC00059; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4916173\n"); + end + x = 64'hC00FFFFFFFFFFFFF; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4918187\n"); + end + x = 64'hC020004000000040; + y = 64'h8010000000000001; + z = 64'hC1FFFFF000800000; + ans = 64'hC1FFFFF000800000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4920201\n"); + end + x = 64'h40AFFFFBFFFFFFF6; + y = 64'hC20000000003FFFD; + z = 64'hC01FFDFFFE000000; + ans = 64'hC2BFFFFC000807EF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4922215\n"); + end + x = 64'hC00FFFFFFFFFFFFF; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4924229\n"); + end + x = 64'hB80F000010000000; + y = 64'hBFD0000000000000; + z = 64'h43C0FDA6886F0D30; + ans = 64'h43C0FDA6886F0D30; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4926243\n"); + end + x = 64'hBF2F80007FFFFFFF; + y = 64'h76D0000000006FFF; + z = 64'h47E0FFFFFF7FFFFE; + ans = 64'hF60F80008000DC7D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4928257\n"); + end + x = 64'hC00FFFFFFFFFFFFF; + y = 64'hBFE0000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4930271\n"); + end + x = 64'h37EFFEFFDFFFFFFF; + y = 64'hBFF0000000000000; + z = 64'hB7EFFFD7FFFFFFFF; + ans = 64'hB7FFFF6BEFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4932285\n"); + end + x = 64'h43C07FBFFFFFFFFE; + y = 64'hCA72000000000007; + z = 64'hB99F3903BA9AF78B; + ans = 64'hCE428FB800000005; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4934299\n"); + end + x = 64'hC00FFFFFFFFFFFFF; + y = 64'hC000000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h4020000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4936313\n"); + end + x = 64'hC7E0000003FFFFFF; + y = 64'hC010000000000000; + z = 64'h395000001FFFC000; + ans = 64'h4800000003FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4938327\n"); + end + x = 64'h4047C422625C8DFB; + y = 64'h3FF000010003FFFF; + z = 64'h42E0000000000700; + ans = 64'h42E0000000000CF1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4940341\n"); + end + x = 64'hC00FFFFFFFFFFFFF; + y = 64'hC340000000000001; + z = 64'h3FF0000000000001; + ans = 64'h4360000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4942355\n"); + end + x = 64'hBFBFFFFFBFFFF7FF; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h40196D6B50F2A50C; + ans = 64'h431FFFFFBFFFF816; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4944369\n"); + end + x = 64'h489FFFEFFFFFEFFE; + y = 64'hB6EFFFFFFFBFFFFC; + z = 64'h3FBFFFFFFFF7EFFE; + ans = 64'h3FB800040007F3F7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -378673,667 +115471,9 @@ initial if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); $fwrite(fp,"4946383\n"); end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hC340000000000000; - zrf = 64'hF10B5A94625B6A0D; - ans = 64'hF10B5A94625B6A0D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4946997\n"); - end - xrf = 64'h3E500624721C4009; - y = 64'hC1C0FFFFFFFEFFFE; - zrf = 64'h3C1087D89181DA93; - ans = 64'hC0210686B93D03A5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4947611\n"); - end - xrf = 64'h3C6000000400001F; - y = 64'hC340000000000001; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'hBFB0000004000020; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4948225\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hF6AFFFFFFFFEFF00; - zrf = 64'hBFD0000000000014; - ans = 64'h76CFFFFFFFFEFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4948839\n"); - end - xrf = 64'hC00FEFFFFFBFFFFE; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h43F94440782563EB; - ans = 64'h43F95438782543EB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4949453\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h43FD52D1182B7CB6; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC41D53D1182B7CB5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4950067\n"); - end - xrf = 64'hC3E07D5FB522A35B; - y = 64'hC3E0000000001FFF; - zrf = 64'hC08FFFFFFFFF03FE; - ans = 64'h47D07D5FB522C455; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4950681\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hFFE0000000000001; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4951295\n"); - end - xrf = 64'h40F5817766005327; - y = 64'h40F0000000803FFE; - zrf = 64'h3FF0000000000000; - ans = 64'h41F5817766BCB4E5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4951909\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h7FD000003FFE0000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4952523\n"); - end - xrf = 64'hC0400087FFFFFFFF; - y = 64'hC150004004000000; - zrf = 64'hC3CF007FFFFFFFFE; - ans = 64'hC3CF007FFFFBFFCC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4953137\n"); - end - xrf = 64'h3F700000000037FE; + x = 64'hC00FFFFFFFFFFFFF; y = 64'hFFF0000000000000; - zrf = 64'h8010000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4953751\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'h425832FD23269F9E; - zrf = 64'h3AFF000001FFFFFF; - ans = 64'hC27832FD23269F9D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4954365\n"); - end - xrf = 64'hBFFFFFFFFFF1FFFE; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hFFDDFFFFFFFFFC00; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4954979\n"); - end - xrf = 64'hC00FFFFFFFFFFFFF; - y = 64'hFFE916121B58C0B3; - zrf = 64'hC340000000000000; + z = 64'hC340000000000000; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -379348,19 +115488,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -379376,5322 +115516,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4955593\n"); + $fwrite(fp,"4948397\n"); end - xrf = 64'hBFA002000000001F; - y = 64'hBFEFFFF7FF000000; - zrf = 64'h4070007F80000000; - ans = 64'h407000FF8FDFF800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4956207\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h0000000000000000; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4956821\n"); - end - xrf = 64'h3B9FFFFF7FFFFFDF; - y = 64'h3DFFFFFFFBFFFFFA; - zrf = 64'h3FE0000000000001; - ans = 64'h3FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4957435\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h0000000000000001; - zrf = 64'hC3CFFFFDFFFFFFEE; - ans = 64'hC3CFFFFDFFFFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4958049\n"); - end - xrf = 64'h43D0020000008000; - y = 64'hBF4FFFF0000FFFFF; - zrf = 64'h0AE000000000040E; - ans = 64'hC33001F7FF0880FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4958663\n"); - end - xrf = 64'hC00982D68CFE066B; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h8000000000000001; - ans = 64'h802982D68CFE0668; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4959277\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h47F0FFFFFFF7FFFF; - zrf = 64'hC1B00800001FFFFE; - ans = 64'hC810FFFFFFF7FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4959891\n"); - end - xrf = 64'h3FFFDFFFFFF00000; - y = 64'h0010000000000001; - zrf = 64'hB84FFFF7FDFFFFFF; - ans = 64'hB84FFFF7FDFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4960505\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h23F008000003FFFE; - zrf = 64'hC010000000000001; - ans = 64'hC010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4961119\n"); - end - xrf = 64'h401FFFFFFF700000; - y = 64'h438F29479C6DA278; - zrf = 64'h6501F1BFF2A961B6; - ans = 64'h6501F1BFF2A961B6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4961733\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4962347\n"); - end - xrf = 64'h346FFFFFFFFFFEEF; - y = 64'h480FFFFEFFFFFFE0; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4962961\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h3CA0000000000000; - zrf = 64'h47FB09E7C2095187; - ans = 64'h47FB09E7C2095187; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4963575\n"); - end - xrf = 64'hC01FF801FFFFFFFE; - y = 64'hC1A000000FFFFDFF; - zrf = 64'h4020000004040000; - ans = 64'h41CFF80223F7FDFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4964189\n"); - end - xrf = 64'hBE410000003FFFFF; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4964803\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'hC7FFF001FFFFFFFE; - zrf = 64'h43E003FFFFFFFFFA; - ans = 64'h481FF001FFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4965417\n"); - end - xrf = 64'h47E000004001FFFF; - y = 64'h3FD0000000000000; - zrf = 64'h3C73FFFFFFFFDFFF; - ans = 64'h47C000004001FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4966031\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'hFFE8201BFB1822CA; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4966645\n"); - end - xrf = 64'hB7E00000201FFFFE; - y = 64'h5501000000007FFF; - zrf = 64'hE8E96E83D48DB4D7; - ans = 64'hE8E96E83D48DB4D7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4967259\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h4018000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4967873\n"); - end - xrf = 64'hFFF4CA66E771B001; - y = 64'hAB9100000000003F; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'hFFFCCA66E771B001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4968487\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h7FE00100FFFFFFFF; - ans = 64'h7FE00100FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4969101\n"); - end - xrf = 64'h3FB4CA462B142534; - y = 64'h3C1000000000081F; - zrf = 64'h3FDFFE0000000000; - ans = 64'h3FDFFE0000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4969715\n"); - end - xrf = 64'h3CD00003FFE00000; - y = 64'h3FE0000000000001; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4970329\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'hB3D063060DC32D6E; - zrf = 64'h480F800000000003; - ans = 64'h480F800000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4970943\n"); - end - xrf = 64'h47FF800000001FFF; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h7FDFFFFFFFFC0FFE; - ans = 64'h7FDFFFFFFFFC0FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4971557\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'hFFDFFF000007FFFF; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4972171\n"); - end - xrf = 64'h085E6E5E94DCC1AE; - y = 64'hE890000800007FFE; - zrf = 64'hC3CFDFFFFFDFFFFE; - ans = 64'hC3CFDFFFFFDFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4972785\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h3FF0000000000001; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'hBCCFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4973399\n"); - end - xrf = 64'h0022000007FFFFFE; - y = 64'hC0E5940371756C20; - zrf = 64'h3CA0000000000000; - ans = 64'h3CA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4974013\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h667FFFFFFFFBBFFE; - ans = 64'h667FFFFFFFFBBFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4974627\n"); - end - xrf = 64'h3D30FFFFFFFDFFFF; - y = 64'hBFCFFF80000FFFFF; - zrf = 64'hB8100200000000FF; - ans = 64'hBD10FFBC00068006; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4975241\n"); - end - xrf = 64'h37F4000000000400; - y = 64'h4000000000000000; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4975855\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h434FFFFFFFBFFFDF; - zrf = 64'h2F2FD7585F5B06A2; - ans = 64'hC36FFFFFFFBFFFDD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4976469\n"); - end - xrf = 64'h43EE57AA497E9EB7; - y = 64'h4000000000000001; - zrf = 64'h3FFFFFFFFFFE01FE; - ans = 64'h43FE57AA497E9EB9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4977083\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h46B003FFFFFFFF00; - zrf = 64'hBFF0000000000000; - ans = 64'hC6D003FFFFFFFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4977697\n"); - end - xrf = 64'h400000FFFFFFFFFE; - y = 64'hC3C7BA574D20B0EB; - zrf = 64'h400000000400007E; - ans = 64'hC3D7BBD2F29582F3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4978311\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h4010000000000000; - zrf = 64'h4000000000000000; - ans = 64'hC02BFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4978925\n"); - end - xrf = 64'h0013FFFC00000000; - y = 64'h3FE0200000000200; - zrf = 64'h0010000000000001; - ans = 64'h001A13FDFC000141; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4979539\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h4010000000000001; - zrf = 64'hC004000000000200; - ans = 64'hC032800000000040; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4980153\n"); - end - xrf = 64'hB3F00FFFFFFFFE00; - y = 64'hBFD0000000000C00; - zrf = 64'h3D49F753324B64B4; - ans = 64'h3D49F753324B64B4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4980767\n"); - end - xrf = 64'h26A8D3A0E3F021DB; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4981381\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h596FFFFDC0000000; - zrf = 64'hC16FFFFFFFFF8002; - ans = 64'hD98FFFFDBFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4981995\n"); - end - xrf = 64'h3FE00007FFFFFEFF; - y = 64'h4340000000000000; - zrf = 64'h40BBB83AC5C0376D; - ans = 64'h4330000800001AB7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4982609\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h3FF00000100007FF; - zrf = 64'hBFE0000000000001; - ans = 64'hC0120000100007FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4983223\n"); - end - xrf = 64'hC3E0000000001DFF; - y = 64'h47EFFFFEFFFEFFFE; - zrf = 64'h43CFFFFBFFEFFFFE; - ans = 64'hCBDFFFFEFFFF3BFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4983837\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h3FF0000000000001; - ans = 64'hC36FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4984451\n"); - end - xrf = 64'h41CFFFFE0000001F; - y = 64'h18EFFFDFFFFFFFF0; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h1ACFFFDE0002000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4985065\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h7FE0000000000000; - zrf = 64'h7FFFFFFFFFFFFF8E; - ans = 64'h7FFFFFFFFFFFFF8E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4985679\n"); - end - xrf = 64'h000E3FFFFFFFFFFE; - y = 64'hC03FFFFFEFFEFFFF; - zrf = 64'h41D00800000FFFFF; - ans = 64'h41D00800000FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4986293\n"); - end - xrf = 64'h434BA547F717BC2E; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4986907\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h402BFFFFEFFFFFFE; - zrf = 64'hC0215B3E1C9E7422; - ans = 64'hC0502B67BB93CE82; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4987521\n"); - end - xrf = 64'h3FF0004004000000; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h3FBFFE0100000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4988135\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h43EFFFFFFFFFDFFC; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hC40FFFFFFFFFDFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4988749\n"); - end - xrf = 64'h3FAFFFFFFF7FFFF8; - y = 64'hC03FFF8000200000; - zrf = 64'hB2AFFC0000000002; - ans = 64'hBFFFFF7FFFA001F8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4989363\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4989977\n"); - end - xrf = 64'hBAF00041FFFFFFFE; - y = 64'h17E68F50F7F1F717; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4990591\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'hFFFFFF0000003FFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4991205\n"); - end - xrf = 64'h3FC800000003FFFE; - y = 64'h41F00001F7FFFFFE; - zrf = 64'h3FBC0000FFFFFFFF; - ans = 64'h41C80002F411FFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4991819\n"); - end - xrf = 64'h41C00FFFFFFFFFFC; - y = 64'h8000000000000001; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4992433\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'hC12FFFFFFFFFFFFF; - zrf = 64'hC01107FFFFFFFFFF; - ans = 64'h414FFFFDDEFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4993047\n"); - end - xrf = 64'hBEC19213529B6F05; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hC0000011FFFFFFFF; - ans = 64'hC0000011FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4993661\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'hBFE000000001C000; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'h400000000001BFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4994275\n"); - end - xrf = 64'h43400000000000BE; - y = 64'h418FFFFFDFFFFFFC; - zrf = 64'h47E004001FFFFFFF; - ans = 64'h47E004002000000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4994889\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h8010000000000001; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4995503\n"); - end - xrf = 64'hBFC002D08C6053BA; - y = 64'hBE300000003EFFFF; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4996117\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h43D0007FFFFFFFEF; - ans = 64'h43D0007FFFFFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4996731\n"); - end - xrf = 64'h3FD00000000041FF; - y = 64'h50AFFFE000007FFF; - zrf = 64'h3FD08000000FFFFF; - ans = 64'h508FFFE0000103FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4997345\n"); - end - xrf = 64'hF04000000000043F; - y = 64'hBCA0000000000000; - zrf = 64'h4000000000000000; - ans = 64'h6CF000000000043F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4997959\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h4176D32464350B30; - zrf = 64'h3D700000800FFFFF; - ans = 64'hC196D32464350B2F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4998573\n"); - end - xrf = 64'h35FD2761D8D690FB; - y = 64'hBCA0000000000001; - zrf = 64'h3F82D0EC235AC18E; - ans = 64'h3F82D0EC235AC18E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4999187\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h43DFF7FFFBFFFFFE; - zrf = 64'hBCA0000000000000; - ans = 64'hC3FFF7FFFBFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"4999801\n"); - end - xrf = 64'hFA793FA061F15340; - y = 64'h439FFFE0007FFFFF; - zrf = 64'hC1F07FDFFFFFFFFF; - ans = 64'hFE293F8722B5EFCF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5000415\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'hBFD0000000000000; - zrf = 64'h3FD0000000000000; - ans = 64'h3FF3FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5001029\n"); - end - xrf = 64'h401000000087FFFF; - y = 64'hC1DFF00000000100; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5001643\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'hBFD0000000000001; - zrf = 64'h43FCAF51984A0307; - ans = 64'h43FCAF51984A0307; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5002257\n"); - end - xrf = 64'hBFD3FEFFFFFFFFFF; - y = 64'h43CC6404F405F460; - zrf = 64'h3FCFFBFFFFFFFFFC; - ans = 64'hC3B1BD9FF85C188B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5002871\n"); - end - xrf = 64'hBFBFF80000003FFF; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h3FF0000000000001; - ans = 64'h3FF0FFC000000201; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5003485\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h802000000003F000; - zrf = 64'h401200000000001F; - ans = 64'h401200000000001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5004099\n"); - end - xrf = 64'hA3AFE00000200000; - y = 64'hBFE0000000000000; - zrf = 64'hC032B1AE831F8947; - ans = 64'hC032B1AE831F8947; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5004713\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'hBF800003FFFFFBFF; - zrf = 64'h8010000000000001; - ans = 64'h3FA00003FFFFFBFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5005327\n"); - end - xrf = 64'h3FC70E0888EF0B4D; - y = 64'h8028194118D5F4AE; - zrf = 64'hBFF75135FDE499CD; - ans = 64'hBFF75135FDE499CD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5005941\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h3CA0000000000001; - ans = 64'h400FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5006555\n"); - end - xrf = 64'h19D8007FFFFFFFFE; - y = 64'hBC142F2153821D5A; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5007169\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'hBFF0000000000000; - zrf = 64'h4CC07FFFFFEFFFFE; - ans = 64'h4CC07FFFFFEFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5007783\n"); - end - xrf = 64'h273FFFFFFFFFFC00; - y = 64'hAE8FFF0001FFFFFF; - zrf = 64'h4C7A32324F901F2A; - ans = 64'h4C7A32324F901F2A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5008397\n"); - end - xrf = 64'h3FE000007E000000; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'hBE9F7FFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5009011\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'hC1EFFFFFFFC08000; - zrf = 64'h3FDFFFFFF8020000; - ans = 64'h420FFFFFFFC47FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5009625\n"); - end - xrf = 64'h533F800000FFFFFE; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h480FFFFFBFFBFFFE; - ans = 64'hD34F800000FFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5010239\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'hC06FFFFC0000001E; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h408FFFFC0000001C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5010853\n"); - end - xrf = 64'h3F4FFFFFFFFF8002; - y = 64'hBFB007FFF7FFFFFF; - zrf = 64'h3815B8A261C215F4; - ans = 64'hBF1007FFF7FFBFE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5011467\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h402FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5012081\n"); - end - xrf = 64'h8024002000000000; - y = 64'h47EDC3E144384BCC; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5012695\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h0017FFFFFFFFDFFE; - ans = 64'h402FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5013309\n"); - end - xrf = 64'h802FFFFF80000002; - y = 64'h317FFFFDFFFFFF7F; - zrf = 64'h3810000080004000; - ans = 64'h3810000080004000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5013923\n"); - end - xrf = 64'h4072426100F60BEB; - y = 64'hC010000000000001; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'hC092406100F60BEC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5014537\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h3F7FFFE000010000; - zrf = 64'h43DFFFFFFFFFF800; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5015151\n"); - end - xrf = 64'hC120FFFFFFFFFBFE; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h47E000800000000E; - ans = 64'h47E000800000000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5015765\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'hC34187E0C6E95983; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5016379\n"); - end - xrf = 64'hC05FFFFC000001FF; - y = 64'h3CAFFFFFFFFEFFBE; - zrf = 64'h47EFFFFFFFFDFFBE; - ans = 64'h47EFFFFFFFFDFFBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5016993\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'hC340000000000001; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h4360000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5017607\n"); - end - xrf = 64'h41DB078F68D379F9; - y = 64'h7FE0000100000007; - zrf = 64'hC010000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5018221\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h4DE383179D19E136; - ans = 64'h4DE383179D19E136; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5018835\n"); - end - xrf = 64'hBEE26DC1E2E1EF19; - y = 64'h403007FFF0000000; - zrf = 64'h43D00001FFFFFFE0; - ans = 64'h43D00001FFFFFFE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5019449\n"); - end - xrf = 64'h7FF07FFFFF7FFFFF; - y = 64'hFFE0000000000000; - zrf = 64'h3FD0000000000000; - ans = 64'h7FF87FFFFF7FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5020063\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h401FFFFFFDFFFDFF; - zrf = 64'hBCACD11955D81A06; - ans = 64'hC03FFFFFFDFFFDFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5020677\n"); - end - xrf = 64'h234440AD7C75FB65; - y = 64'hFFE0000000000001; - zrf = 64'hC34FFFE003FFFFFE; - ans = 64'hE33440AD7C75FB66; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5021291\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h3FDFC7DD884FB7E0; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5021905\n"); - end - xrf = 64'h43400000000047FE; - y = 64'h37E0020001000000; - zrf = 64'h3FBFEFFFFFEFFFFF; - ans = 64'h3FBFEFFFFFEFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5022519\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'hFFF0000000000000; - zrf = 64'h0000000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5023133\n"); - end - xrf = 64'h5E25B19220749820; - y = 64'h41E1FFFFFFFFFFFF; - zrf = 64'hC000000000000001; - ans = 64'h601867C464832B23; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5023747\n"); - end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'hFFF0000000000001; - zrf = 64'h45100001BFFFFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5024361\n"); - end - xrf = 64'h049FFF0000000020; - y = 64'hBE40007FFFFFFFFC; - zrf = 64'h6BC03FFFEFFFFFFF; - ans = 64'h6BC03FFFEFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5024975\n"); - end - xrf = 64'h401EFFFEFFFFFFFE; + x = 64'hC3F99F723708B50D; y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h3CA0000000000001; + z = 64'h476000400000003F; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -384706,19 +115535,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -384734,12 +115563,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5025589\n"); + $fwrite(fp,"4950411\n"); end - xrf = 64'hC00FFFFFFFFFFFFE; - y = 64'h357FFEFFDFFFFFFF; - zrf = 64'hABABFFFFFFFFFBFF; - ans = 64'hB59FFEFFDFFFFFFD; + x = 64'hC09FFFFFC000007F; + y = 64'hC800000000040FFE; + z = 64'hBD0000000001EFFF; + ans = 64'h48AFFFFFC008207B; rn = 1; rz = 0; rm = 0; @@ -384753,19 +115582,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -384781,247 +115610,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5026203\n"); + $fwrite(fp,"4952425\n"); end - xrf = 64'h3FB00000003FFFF8; - y = 64'h0000000000000000; - zrf = 64'hC320800000000000; - ans = 64'hC320800000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5026817\n"); - end - xrf = 64'hC010000000000000; - y = 64'hC1FFFFFFDFFFFFF7; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5027431\n"); - end - xrf = 64'h742001FFFFFFFFFF; - y = 64'hB055DDF708C18FDD; - zrf = 64'hC7E00003FF000000; - ans = 64'hE485E0B2C7A2A80E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5028045\n"); - end - xrf = 64'hC010000000000000; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5028659\n"); - end - xrf = 64'h434FFFFFFFFFFFA0; - y = 64'h4007CFD08BB64374; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'h4367CFD08BB6432C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5029273\n"); - end - xrf = 64'hC010000000000000; + x = 64'hC00FFFFFFFFFFFFE; y = 64'h0010000000000000; - zrf = 64'h9A9223B531FD7E1B; - ans = 64'h9A9223B531FD7E1B; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -385035,19 +115629,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -385063,153 +115657,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5029887\n"); + $fwrite(fp,"4954439\n"); end - xrf = 64'hC320000000000000; - y = 64'hBFDFFFFFF000007F; - zrf = 64'h4330000000081FFE; - ans = 64'h4333FFFFFE08200E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5030501\n"); - end - xrf = 64'h40300000001003FE; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h00610000001003FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5031115\n"); - end - xrf = 64'hC010000000000000; - y = 64'hB0F0000010001FFF; - zrf = 64'hC020619CD5CAF20E; - ans = 64'hC020619CD5CAF20E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5031729\n"); - end - xrf = 64'hB8000000FFFFFF7F; + x = 64'h3FEFC10000000000; y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hBFE00100007FFFFF; - ans = 64'hBFE00100007FFFFF; + z = 64'h3FC001FFFF7FFFFF; + ans = 64'h3FC001FFFF7FFFFF; rn = 1; rz = 0; rm = 0; @@ -385223,19 +115676,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -385251,12 +115704,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5032343\n"); + $fwrite(fp,"4956453\n"); end - xrf = 64'hC010000000000000; - y = 64'h41CE000000000000; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFF87FFFFFF; + x = 64'hBFEFFFFFBFFFFFEF; + y = 64'h4000040FFFFFFFFE; + z = 64'h51D868ED5ABEC329; + ans = 64'h51D868ED5ABEC329; rn = 1; rz = 0; rm = 0; @@ -385270,19 +115723,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -385298,12 +115751,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5032957\n"); + $fwrite(fp,"4958467\n"); end - xrf = 64'hC30000201FFFFFFF; - y = 64'h38100000000BFFFF; - zrf = 64'hBFC0001800000000; - ans = 64'hBFC0001800000000; + x = 64'hC00FFFFFFFFFFFFE; + y = 64'h3FD0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hBFEFFFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -385317,19 +115770,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -385345,294 +115798,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5033571\n"); + $fwrite(fp,"4960481\n"); end - xrf = 64'hC010000000000000; - y = 64'h3CA0000000000001; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5034185\n"); - end - xrf = 64'hC3EFB7FFFFFFFFFE; - y = 64'hC01FFFFFFFFFF7EF; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'h441FB7FFFFFFF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5034799\n"); - end - xrf = 64'hC010000000000000; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'hBFD000000000083E; - ans = 64'hBFD000000000084E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5035413\n"); - end - xrf = 64'hC1EFFFFFFFFFFFE7; - y = 64'hBFEFFFFFFFF80007; - zrf = 64'h800FFFFFF0007FFE; - ans = 64'h41EFFFFFFFF7FFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5036027\n"); - end - xrf = 64'h3C4003FFFFFFFFDF; - y = 64'h3FD0000000000001; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h3C2003FFFFFFFFE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5036641\n"); - end - xrf = 64'hC010000000000000; - y = 64'hC3C00000FFEFFFFF; - zrf = 64'h7FE90E1F87DFCF0B; - ans = 64'h7FE90E1F87DFCF0B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5037255\n"); - end - xrf = 64'hC00FFFFFFFF00007; + x = 64'h42FB1185BF70CCEC; y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hBFB2A26DAD6E55C2; - ans = 64'hC00095136D6372B1; + z = 64'h14904C9B2DC78348; + ans = 64'h42EB1185BF70CCEB; rn = 1; rz = 0; rm = 0; @@ -385646,19 +115817,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -385674,12 +115845,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5037869\n"); + $fwrite(fp,"4962495\n"); end - xrf = 64'hC010000000000000; - y = 64'hC590007FFFFFEFFE; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h45B0007FFFFFEFFE; + x = 64'h4020000000010000; + y = 64'h47FFFFFFFFFC2000; + z = 64'h3CA2F1AC81C05D0C; + ans = 64'h482FFFFFFFFE2000; rn = 1; rz = 0; rm = 0; @@ -385693,19 +115864,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -385721,12 +115892,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5038483\n"); + $fwrite(fp,"4964509\n"); end - xrf = 64'hC01FFFFFFFC00001; - y = 64'hBFD00000000001FB; - zrf = 64'h43460B4D4D7E4B14; - ans = 64'h43460B4D4D7E4B15; + x = 64'hC00FFFFFFFFFFFFE; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hC013FFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -385740,19 +115911,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -385768,12 +115939,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5039097\n"); + $fwrite(fp,"4966523\n"); end - xrf = 64'hC010000000000000; - y = 64'h3FE0000000000000; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFF; + x = 64'hBFC0001FFE000000; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h43EE9D7600EAEAAB; + ans = 64'h43EE9D7600EAEAAB; rn = 1; rz = 0; rm = 0; @@ -385787,19 +115958,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -385815,12 +115986,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5039711\n"); + $fwrite(fp,"4968537\n"); end - xrf = 64'hC0D00BFFFFFFFFFF; - y = 64'h4052000000000003; - zrf = 64'hBFE0000000000000; - ans = 64'hC1320D8080000002; + x = 64'h001F53634F83EF23; + y = 64'hC1FFFFF400000000; + z = 64'h3FC725099455170F; + ans = 64'h3FC725099455170F; rn = 1; rz = 0; rm = 0; @@ -385834,19 +116005,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -385862,12 +116033,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5040325\n"); + $fwrite(fp,"4970551\n"); end - xrf = 64'hC010000000000000; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'hB817FFFFFFFFFFF7; - ans = 64'hC00FFFFFFFFFFFFF; + x = 64'hC00FFFFFFFFFFFFE; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h433FFFFFFFFFFFF0; rn = 1; rz = 0; rm = 0; @@ -385881,19 +116052,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -385909,12 +116080,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5040939\n"); + $fwrite(fp,"4972565\n"); end - xrf = 64'hBE00000001000080; - y = 64'hBFDBFFFFFFFFFFDE; - zrf = 64'hC0100000008FFFFF; - ans = 64'hC0100000008C7FFF; + x = 64'h4320037FFFFFFFFF; + y = 64'h4010000000000001; + z = 64'h41FDC4B3A046B212; + ans = 64'h43400380EE259D02; rn = 1; rz = 0; rm = 0; @@ -385928,19 +116099,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -385956,12 +116127,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5041553\n"); + $fwrite(fp,"4974579\n"); end - xrf = 64'h381000008000003F; - y = 64'h3FF0000000000000; - zrf = 64'h0000000000000000; - ans = 64'h381000008000003F; + x = 64'hC3D000000001000F; + y = 64'h3FF000020000FFFF; + z = 64'hC03FFFF00000001E; + ans = 64'hC3D000020002000E; rn = 1; rz = 0; rm = 0; @@ -385975,19 +116146,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -386003,12 +116174,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5042167\n"); + $fwrite(fp,"4976593\n"); end - xrf = 64'hC010000000000000; - y = 64'h381FFC0040000000; - zrf = 64'h3F852811C4620EBE; - ans = 64'h3F852811C4620EBE; + x = 64'hC00FFFFFFFFFFFFE; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -386022,19 +116193,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -386050,999 +116221,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5042781\n"); + $fwrite(fp,"4978607\n"); end - xrf = 64'h43D4CA49C18FEFA7; - y = 64'h3FF0000000000001; - zrf = 64'hB7FFF000000003FF; - ans = 64'h43D4CA49C18FEFA8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5043395\n"); - end - xrf = 64'hC010000000000000; - y = 64'hC340874463F08699; - zrf = 64'h4010000000000000; - ans = 64'h4360874463F0869A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5044009\n"); - end - xrf = 64'h406FFFFBFFFDFFFF; - y = 64'hCE5FFFFFEFFF7FFE; - zrf = 64'hBFFFEFFFFFFFFFDF; - ans = 64'hCEDFFFFBEFFD81FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5044623\n"); - end - xrf = 64'hC010000000000000; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5045237\n"); - end - xrf = 64'hBF70000040000004; - y = 64'hFFD2FFFFFFFFFFFF; - zrf = 64'hBFD0000000000001; - ans = 64'h7F5300004C000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5045851\n"); - end - xrf = 64'hC010000000000000; - y = 64'h4000000000000001; - zrf = 64'hBFE6D815FEE186EC; - ans = 64'hC0216D815FEE1870; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5046465\n"); - end - xrf = 64'hC050400002000000; - y = 64'h663FFFFF01000000; - zrf = 64'h4027C15967E6E4C0; - ans = 64'hE6A03FFF8081FFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5047079\n"); - end - xrf = 64'h366400000000000F; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5047693\n"); - end - xrf = 64'hC010000000000000; - y = 64'h43FFFFFFFFFFFFC0; - zrf = 64'h3FD0007FFFE00000; - ans = 64'hC41FFFFFFFFFFFC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5048307\n"); - end - xrf = 64'h380000FEFFFFFFFE; - y = 64'h4010000000000000; - zrf = 64'hC06FFF000000001F; - ans = 64'hC06FFF000000001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5048921\n"); - end - xrf = 64'hC010000000000000; - y = 64'h41DFE000000007FE; - zrf = 64'h4000000000000001; - ans = 64'hC1FFDFFFFFE007FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5049535\n"); - end - xrf = 64'h434FFFFFFFFDFFBF; - y = 64'hC67C0FFFFFFFFFFE; - zrf = 64'h59ABFBFFFFFFFFFE; - ans = 64'h59ABFBFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5050149\n"); - end - xrf = 64'hC010000000000000; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hC010000000000001; - ans = 64'hC042000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5050763\n"); - end - xrf = 64'h403C4BB643B41BE6; - y = 64'hE4FFC00000080000; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hE54C131ED733C69C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5051377\n"); - end - xrf = 64'hC010000000000000; - y = 64'h4340000000000000; - zrf = 64'h0017B965DFF7B108; - ans = 64'hC360000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5051991\n"); - end - xrf = 64'h380020000000007E; - y = 64'hBF5F4468DC6E311D; - zrf = 64'hBFB250C265D86A0A; - ans = 64'hBFB250C265D86A0A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5052605\n"); - end - xrf = 64'h406FFFE000000000; - y = 64'h4340000000000001; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5053219\n"); - end - xrf = 64'hC010000000000000; - y = 64'hC3F00007FFFFEFFE; - zrf = 64'h38100200000007FE; - ans = 64'h44100007FFFFEFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5053833\n"); - end - xrf = 64'hC34FFFF03FFFFFFF; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h401DFE1050723CC8; - ans = 64'hC6AFFFF03FFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5054447\n"); - end - xrf = 64'hC010000000000000; - y = 64'h44CE2A3942DD7BBF; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'hC4EE2A3942DD7BBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5055061\n"); - end - xrf = 64'h47EFFFFFFFFFFFFF; - y = 64'hC08FFFFFFFFFF5FF; - zrf = 64'hBEBFFDFFFFFFFFEF; - ans = 64'hC88FFFFFFFFFF5FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5055675\n"); - end - xrf = 64'hC010000000000000; + x = 64'h480FFFFFFBFBFFFF; y = 64'h7FE0000000000001; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; + z = 64'hB800000083FFFFFF; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -387056,19 +116240,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -387084,12 +116268,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5056289\n"); + $fwrite(fp,"4980621\n"); end - xrf = 64'hCEE5D260452DBE46; - y = 64'hC01C90566DBB7CCA; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h4F137A81DDF680A8; + x = 64'h41D07FFFFF800000; + y = 64'hC010FFFFFFBFFFFE; + z = 64'hBFD07FFFFFFFFFDF; + ans = 64'hC1F187FFFF3A1FFE; rn = 1; rz = 0; rm = 0; @@ -387103,19 +116287,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -387131,199 +116315,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5056903\n"); + $fwrite(fp,"4982635\n"); end - xrf = 64'hC010000000000000; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h3FEFFFF800001FFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5057517\n"); - end - xrf = 64'h64AFBFFFDFFFFFFF; - y = 64'hC024968751F44CE7; - zrf = 64'hBFC9D9703A92EAD2; - ans = 64'hE4E46D5A2EB9DCFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5058131\n"); - end - xrf = 64'hBFD07FF7FFFFFFFF; - y = 64'h7FF0000000000000; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5058745\n"); - end - xrf = 64'hC010000000000000; - y = 64'h41D1FFF000000000; - zrf = 64'hC1FEFFFFFFF80000; - ans = 64'hC2087FF7FFFC0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5059359\n"); - end - xrf = 64'h403B4A4ECF91F4C5; + x = 64'hC00FFFFFFFFFFFFE; y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h663EC41BBCC432ED; + z = 64'hBCAFFFFFFFFFFFFF; ans = 64'h7FFFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -387338,19 +116334,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -387366,5464 +116362,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5059973\n"); + $fwrite(fp,"4984649\n"); end - xrf = 64'hC010000000000000; - y = 64'hC030007FFFDFFFFF; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h4050407FFFDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5060587\n"); - end - xrf = 64'h41FE4BE8FF9DF902; - y = 64'hC180000003FF7FFF; - zrf = 64'hB80FFFF000020000; - ans = 64'hC38E4BE9073000E1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5061201\n"); - end - xrf = 64'hC010000000000000; - y = 64'h8000000000000000; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hBFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5061815\n"); - end - xrf = 64'h43F7E7FD47697DD4; - y = 64'h41CFFFFFFFFFF7FB; - zrf = 64'h8010000000000000; - ans = 64'h45D7E7FD476977D6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5062429\n"); - end - xrf = 64'hC010000000000000; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h0AAFFFFFFFF7FFFF; - ans = 64'h0AAFFFFFFFF7FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5063043\n"); - end - xrf = 64'h3B0344D2CF3BC0E1; - y = 64'h401340CF6F795F2C; - zrf = 64'h43F11599DC4DD456; - ans = 64'h43F11599DC4DD456; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5063657\n"); - end - xrf = 64'hBFBFFFFFFBFF7FFF; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5064271\n"); - end - xrf = 64'hC010000000000000; - y = 64'h80215EA9AA03E958; - zrf = 64'hC13001F7FFFFFFFF; - ans = 64'hC13001F7FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5064885\n"); - end - xrf = 64'h3F90003FFFFFFFF0; - y = 64'h8010000000000001; - zrf = 64'h434FFFFF7FFC0000; - ans = 64'h434FFFFF7FFC0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5065499\n"); - end - xrf = 64'hC010000000000000; - y = 64'hAAB6C32FA358DB68; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5066113\n"); - end - xrf = 64'h400FFFFFFFF8003E; - y = 64'hC1CBC49A65816807; - zrf = 64'h4014247B6BB4F7DB; - ans = 64'hC1EBC49A64D9533B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5066727\n"); - end - xrf = 64'hC010000000000000; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'hBFF0000000000000; - ans = 64'hBFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5067341\n"); - end - xrf = 64'hC02FFFFFFFF7FFDE; - y = 64'hC1EF6753ADB21E70; - zrf = 64'h8000000000000001; - ans = 64'h422F6753ADAA447A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5067955\n"); - end - xrf = 64'hC010000000000000; - y = 64'hBCA0000000000001; - zrf = 64'hC857FB20ED114B94; - ans = 64'hC857FB20ED114B94; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5068569\n"); - end - xrf = 64'h40200000000023FF; - y = 64'hC03E33FDDA29A3AC; - zrf = 64'h43D00FFFF0000000; - ans = 64'h43D00FFFF0000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5069183\n"); - end - xrf = 64'h3F002000FFFFFFFE; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'hC010000000000001; - ans = 64'hC010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5069797\n"); - end - xrf = 64'hC010000000000000; - y = 64'hC1EFF800FFFFFFFF; - zrf = 64'h38155E3BB7C7DEB4; - ans = 64'h420FF800FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5070411\n"); - end - xrf = 64'hC1C00800003FFFFF; - y = 64'hBFD0000000000000; - zrf = 64'h3D1FFFFF7FFFE000; - ans = 64'h41A00800003FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5071025\n"); - end - xrf = 64'hC010000000000000; - y = 64'hC7EFFFF0FFFFFFFE; - zrf = 64'h3FD0000000000001; - ans = 64'h480FFFF0FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5071639\n"); - end - xrf = 64'h435CF62CB1F62DB0; - y = 64'h412000003FBFFFFF; - zrf = 64'h4619044E4536474D; - ans = 64'h4619044E53B15DE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5072253\n"); - end - xrf = 64'hC010000000000000; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hBFE0000000000001; - ans = 64'h3FF7FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5072867\n"); - end - xrf = 64'hA0BFFFC0001FFFFF; - y = 64'h4030DDDBC20FD050; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5073481\n"); - end - xrf = 64'hC010000000000000; - y = 64'hBFE0000000000000; - zrf = 64'h41800B863A1790FE; - ans = 64'h41800B864A1790FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5074095\n"); - end - xrf = 64'h51400FEFFFFFFFFE; - y = 64'hBFBFFF000000007F; - zrf = 64'hBFDBFFFFFDFFFFFE; - ans = 64'hD1100F6F8080003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5074709\n"); - end - xrf = 64'hBF222E5E9FF7EA22; - y = 64'hBFE0000000000001; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC00FFFDBA342C00F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5075323\n"); - end - xrf = 64'hC010000000000000; - y = 64'hB803676F25093A46; - zrf = 64'h29E000400000007F; - ans = 64'h3823676F25093A46; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5075937\n"); - end - xrf = 64'h609FFFFFFDFFBFFE; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hBE13F29061685719; - ans = 64'hE09FFFFFFDFFBFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5076551\n"); - end - xrf = 64'hC010000000000000; - y = 64'hC8000FFFF7FFFFFF; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h48200FFFF7FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5077165\n"); - end - xrf = 64'h43D508A9A3AA2758; - y = 64'hBEFB988565F24AE0; - zrf = 64'h3FD000001007FFFF; - ans = 64'hC2E2238FF6E4A3C7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5077779\n"); - end - xrf = 64'hC010000000000000; - y = 64'hBFF0000000000001; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'h400C000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5078393\n"); - end - xrf = 64'h3C7FFFFFF8100000; - y = 64'hC25055974D7337CD; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5079007\n"); - end - xrf = 64'hC010000000000000; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hBFCFBFFFFFFFFEFE; - ans = 64'h401F020000000006; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5079621\n"); - end - xrf = 64'hBF8FFFFFFEFFFFFE; - y = 64'hA9C000004000007F; - zrf = 64'hC80FFFFFFFF8007F; - ans = 64'hC80FFFFFFFF8007F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5080235\n"); - end - xrf = 64'h40100003FFFFFFFD; - y = 64'hC000000000000000; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hC0240003FFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5080849\n"); - end - xrf = 64'hC010000000000000; - y = 64'hBFC0000000003F00; - zrf = 64'h3FF00AF34655D1DB; - ans = 64'h3FF80AF34655F15B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5081463\n"); - end - xrf = 64'hC01FFEFFFFFF8000; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'hBF9C32F900EC4CE9; - ans = 64'h403FF7F341BF44EC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5082077\n"); - end - xrf = 64'hC010000000000000; - y = 64'hC3DFDE0000000000; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h43FFDE0000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5082691\n"); - end - xrf = 64'h3D471BC59AF97A79; - y = 64'hC0307FFE00000000; - zrf = 64'h7EEFFFFFFC1FFFFF; - ans = 64'h7EEFFFFFFC1FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5083305\n"); - end - xrf = 64'hC010000000000000; - y = 64'hC010000000000000; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'h4030000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5083919\n"); - end - xrf = 64'h7FFFFFFFF83FFFFE; - y = 64'h002184CB44472841; - zrf = 64'h7FE0000000000000; - ans = 64'h7FFFFFFFF83FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5084533\n"); - end - xrf = 64'hC010000000000000; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hC3E01FFFFFFFFFEF; - ans = 64'hC3E01FFFFFFFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5085147\n"); - end - xrf = 64'hBFBFFFFFFFFBFFEE; - y = 64'h3FD1FFFBFFFFFFFF; - zrf = 64'h43472831D0C4B42B; - ans = 64'h43472831D0C4B42B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5085761\n"); - end - xrf = 64'hC3B0000100000002; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hBFF0000000000000; - ans = 64'h43E0000100000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5086375\n"); - end - xrf = 64'hC010000000000000; - y = 64'hC03FFFDFFDFFFFFE; - zrf = 64'h455EFF7FFFFFFFFF; - ans = 64'h455EFF7FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5086989\n"); - end - xrf = 64'h4FF00000FFDFFFFF; - y = 64'hC340000000000001; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'hD3400000FFE00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5087603\n"); - end - xrf = 64'hC010000000000000; - y = 64'h4800002000FFFFFF; - zrf = 64'h0010000000000000; - ans = 64'hC820002000FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5088217\n"); - end - xrf = 64'hC12000000077FFFE; - y = 64'hC57E000001FFFFFF; - zrf = 64'h3FF000003FFFFFBF; - ans = 64'h46AE000002E0FFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5088831\n"); - end - xrf = 64'hC010000000000000; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hBCA0000000000000; - ans = 64'h436FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5089445\n"); - end - xrf = 64'hB81C8CD3490B9979; - y = 64'h7FE00000100003FF; - zrf = 64'h4340000000000001; - ans = 64'hF80C8CD3659873E3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5090059\n"); - end - xrf = 64'hC010000000000000; - y = 64'hFFE0000000000001; - zrf = 64'hC29FFFFC001FFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5090673\n"); - end - xrf = 64'hC3C48D1D93DDD025; - y = 64'h3F9FFFFFFFFFFBE0; - zrf = 64'hBFC3A703037E2FB7; - ans = 64'hC3748D1D93DDCD7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5091287\n"); - end - xrf = 64'h43DFFFFFC000001F; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hBFE0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5091901\n"); - end - xrf = 64'hC010000000000000; - y = 64'h917C0000FFFFFFFE; - zrf = 64'hB6B8312B22FC8ABE; - ans = 64'hB6B8312B22FC8ABE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5092515\n"); - end - xrf = 64'h3E307FDFFFFFFFFF; - y = 64'hFFF0000000000000; - zrf = 64'h37FFFFFFFF7FFFF8; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5093129\n"); - end - xrf = 64'hC010000000000000; - y = 64'h37F0000010000FFF; - zrf = 64'h0000000000000001; - ans = 64'hB810000010000FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5093743\n"); - end - xrf = 64'h47F1E7C055FAD3AD; - y = 64'hC02FFFF800003FFE; - zrf = 64'hB7F918E2D83418A2; - ans = 64'hC831E7BBDC0AE1FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5094357\n"); - end - xrf = 64'hC010000000000000; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h8010000000000001; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5094971\n"); - end - xrf = 64'h3FE003FDFFFFFFFF; - y = 64'h43C4FFFFFFFFFFFF; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h43B5053D5FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5095585\n"); - end - xrf = 64'hC010000000000001; - y = 64'h0000000000000000; - zrf = 64'hC3E1A1B793961FA7; - ans = 64'hC3E1A1B793961FA7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5096199\n"); - end - xrf = 64'hC03FFFFFFFFE000E; - y = 64'hBFF606D27DB53E58; - zrf = 64'hFFF4D6092EF4DBDE; - ans = 64'hFFFCD6092EF4DBDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5096813\n"); - end - xrf = 64'h8004DED27ECA65EF; - y = 64'h0000000000000001; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5097427\n"); - end - xrf = 64'hC010000000000001; - y = 64'hC692C0370BB8C5E4; - zrf = 64'hBFBFFFFF7F000000; - ans = 64'h46B2C0370BB8C5E5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5098041\n"); - end - xrf = 64'h3DFFFFFFBFF7FFFF; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hC02FFFFFFFDFFBFE; - ans = 64'hC02FFFFFFFDFFBFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5098655\n"); - end - xrf = 64'hC010000000000001; - y = 64'hBFB0000400000002; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5099269\n"); - end - xrf = 64'h403D6CCEE423D252; - y = 64'hBF10000000083FFF; - zrf = 64'hBE100007FFFF7FFE; - ans = 64'hBF5D6CCFE4337E6B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5099883\n"); - end - xrf = 64'hC010000000000001; - y = 64'h0010000000000001; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h8034000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5100497\n"); - end - xrf = 64'h47300FFFFFFFFFFF; - y = 64'h56500000010000FF; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h5D901000010100FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5101111\n"); - end - xrf = 64'hC010000000000001; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hBFA00000FBFFFFFF; - ans = 64'hBFA00000FBFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5101725\n"); - end - xrf = 64'h80194AE79F13DB09; - y = 64'h00001FFFFFFFFFF6; - zrf = 64'h31B0000000100000; - ans = 64'h31B0000000100000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5102339\n"); - end - xrf = 64'hC1000001EFFFFFFF; - y = 64'h3CA0000000000000; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hBDB00011EFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5102953\n"); - end - xrf = 64'hC010000000000001; - y = 64'h380FFFFC0FFFFFFE; - zrf = 64'hB80D6AE911DE38D8; - ans = 64'hB833AD5B2A3BC71B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5103567\n"); - end - xrf = 64'h322D873FD0131513; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h8000000400000040; - ans = 64'h2EED873FD0131512; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5104181\n"); - end - xrf = 64'hC010000000000001; - y = 64'h38C01FFFFFFFBFFF; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5104795\n"); - end - xrf = 64'hB7E0000000000300; - y = 64'h42EFFF80003FFFFF; - zrf = 64'hB7F00000007BFFFF; - ans = 64'hBADFFF800040063F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5105409\n"); - end - xrf = 64'hC010000000000001; - y = 64'h3FD0000000000000; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5106023\n"); - end - xrf = 64'h3EFFFFFEF7FFFFFE; - y = 64'hC2ABFFF7FFFFFFFF; - zrf = 64'h4000000000000000; - ans = 64'hC1BBFFF7170041FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5106637\n"); - end - xrf = 64'hC010000000000001; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h5B60000020000010; - ans = 64'h5B60000020000010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5107251\n"); - end - xrf = 64'h37FFFDDFFFFFFFFF; - y = 64'hBFF100000007FFFF; - zrf = 64'h41C0000201FFFFFF; - ans = 64'h41C0000201FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5107865\n"); - end - xrf = 64'hFFDEFFFFFBFFFFFF; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'hBCA0000000000000; - ans = 64'hFFCEFFFFFBFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5108479\n"); - end - xrf = 64'hC010000000000001; - y = 64'h3FF00007FFF80000; - zrf = 64'hC76FFFFFFF7F0000; - ans = 64'hC76FFFFFFF7F0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5109093\n"); - end - xrf = 64'hC3EFDFFFFFFFFFFD; - y = 64'h3FE0000000000001; - zrf = 64'hC1D000800003FFFE; - ans = 64'hC3DFE0000010007F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5109707\n"); - end - xrf = 64'hC010000000000001; - y = 64'h3FCFFFFFFFEF7FFF; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5110321\n"); - end - xrf = 64'h43DC0C95BFF76485; - y = 64'hDF8FFFFFE00001FF; - zrf = 64'h4000007FDFFFFFFF; - ans = 64'hE37C0C95A3EAD085; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5110935\n"); - end - xrf = 64'hC010000000000001; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5111549\n"); - end - xrf = 64'h7FE0000000010000; - y = 64'h3FF772B7E0D7D75C; - zrf = 64'h3FF0000000000001; - ans = 64'h7FE772B7E0D94E87; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5112163\n"); - end - xrf = 64'hC010000000000001; - y = 64'h3FF0000000000001; - zrf = 64'h801F7DFFFFFFFFFF; - ans = 64'hC010000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5112777\n"); - end - xrf = 64'h3FD1D4DA2501AD28; - y = 64'hC1EF800000000004; - zrf = 64'h401022ACB0CDB739; - ans = 64'hC1D18D86BB6B7BAB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5113391\n"); - end - xrf = 64'h415007FFFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h8010000000000001; - ans = 64'h416007FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5114005\n"); - end - xrf = 64'hC010000000000001; - y = 64'h43DFBF7FFFFFFFFF; - zrf = 64'hC3F0000F7FFFFFFE; - ans = 64'hC407DFC7BFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5114619\n"); - end - xrf = 64'hBFDFFF7FFFFF8000; - y = 64'h4000000000000000; - zrf = 64'hDFB000000401FFFF; - ans = 64'hDFB000000401FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5115233\n"); - end - xrf = 64'hC010000000000001; - y = 64'h433E68C656F569DC; - zrf = 64'hC340000000000001; - ans = 64'hC36334632B7AB4EF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5115847\n"); - end - xrf = 64'hC3CFFFFFFFF60000; - y = 64'hBF40000000000F7F; - zrf = 64'hC3C000000FFFFC00; - ans = 64'hC3BFF8001FFFFA78; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5116461\n"); - end - xrf = 64'hC010000000000001; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5117075\n"); - end - xrf = 64'h3CA0000003800000; - y = 64'h8DBFFFFE00000002; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5117689\n"); - end - xrf = 64'hC010000000000001; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hC5E007FFFFDFFFFF; - ans = 64'hC5E007FFFFDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5118303\n"); - end - xrf = 64'hD5E00000FFFFFBFF; - y = 64'hBFD5FE8F3F5DEF1C; - zrf = 64'hBFEC375F0C0A86BA; - ans = 64'h55C5FE909F46DD91; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5118917\n"); - end - xrf = 64'h303FFFFFE8000000; - y = 64'h4010000000000001; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h305FFFFFE8000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5119531\n"); - end - xrf = 64'hC010000000000001; - y = 64'h24100000000400FF; - zrf = 64'h3C6FFE00000003FF; - ans = 64'h3C6FFE00000003FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5120145\n"); - end - xrf = 64'hBF600000FFFE0000; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h405FFFF8000003FF; - ans = 64'h405FFEF7FFF0041F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5120759\n"); - end - xrf = 64'hC010000000000001; - y = 64'h43EFFFFFDFFBFFFE; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC40FFFFFDFFC0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5121373\n"); - end - xrf = 64'h47EFFFDFFFEFFFFE; - y = 64'hC6BB9BE295B61472; - zrf = 64'h3FBFFDFFFFDFFFFF; - ans = 64'hCEBB9BC6F9C5B0C9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5121987\n"); - end - xrf = 64'hC010000000000001; - y = 64'h4340000000000001; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'hC350000000000005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5122601\n"); - end - xrf = 64'hC7F2BF3274E646E9; - y = 64'hBFAFFFFFFFFAFFFE; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h47B2BF3274E35908; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5123215\n"); - end - xrf = 64'hC010000000000001; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'hC2FFFEFFFFFFBFFE; - ans = 64'hC3701FFEFFFFFFC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5123829\n"); - end - xrf = 64'hC2FD573446B9E433; - y = 64'h8000FFFFFFFFFBFF; - zrf = 64'h46D00001FFFFFDFF; - ans = 64'h46D00001FFFFFDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5124443\n"); - end - xrf = 64'h3C3FFFFFFDFFFFF6; - y = 64'h7FE0000000000000; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5125057\n"); - end - xrf = 64'hC010000000000001; - y = 64'h43FFFFFFFFFF0002; - zrf = 64'hC00FFFFFFF3FFFFF; - ans = 64'hC41FFFFFFFFF0004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5125671\n"); - end - xrf = 64'hC7E00200003FFFFF; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hF0533D6A77D98B1A; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5126285\n"); - end - xrf = 64'hC010000000000001; - y = 64'h3FE684C4185FB7F8; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC01B42620C2FDBFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5126899\n"); - end - xrf = 64'h38045A359C8F05BA; - y = 64'h422FFFF7FFE00000; - zrf = 64'hC1CFFFFE003FFFFF; - ans = 64'hC1CFFFFE003FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5127513\n"); - end - xrf = 64'hC010000000000001; - y = 64'h7FF0000000000000; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5128127\n"); - end - xrf = 64'hC1EF0000000007FF; - y = 64'hC2A00000400007FE; - zrf = 64'h3FD0000000000000; - ans = 64'h449F00007C00177B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5128741\n"); - end - xrf = 64'hC010000000000001; - y = 64'h7FF0000000000001; - zrf = 64'hC345B7B3CDBBDF5B; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5129355\n"); - end - xrf = 64'h464DFFFFFEFFFFFF; - y = 64'hB9DFFFFFFFFFFFFF; - zrf = 64'h400FFFFFFF8FFFFF; - ans = 64'hC039FFFFFF0DFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5129969\n"); - end - xrf = 64'h97D0000000200FFF; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h7FF0000000000000; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5130583\n"); - end - xrf = 64'hC010000000000001; - y = 64'h40AFFFFFFF7FFDFF; - zrf = 64'hC3E868E0046757DE; - ans = 64'hC3E868E0046757E6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5131197\n"); - end - xrf = 64'h3F1FFFFFFFFFFFC1; + x = 64'h6EC000000007FDFF; y = 64'h8000000000000001; - zrf = 64'hC12FFFFFFEFFFEFF; - ans = 64'hC12FFFFFFEFFFEFF; + z = 64'hC1D93B5D4A2A8ABD; + ans = 64'hC1D93B5D4A2A8ABD; rn = 1; rz = 0; rm = 0; @@ -392837,19 +116381,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -392865,12 +116409,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5131811\n"); + $fwrite(fp,"4986663\n"); end - xrf = 64'hC010000000000001; - y = 64'hC1E000020007FFFE; - zrf = 64'hC000000000000000; - ans = 64'h42000001FFF7FFFF; + x = 64'hC3EFFDFFFFFFF7FE; + y = 64'hFFE57370E59E6D25; + z = 64'hC007FFFFFFFF7FFF; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -392884,19 +116428,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -392912,27318 +116456,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5132425\n"); + $fwrite(fp,"4988677\n"); end - xrf = 64'hC00F03111F764430; - y = 64'hC0100008000003FE; - zrf = 64'hC1D08B071EEBF1C0; - ans = 64'hC1D08B071B0B8DAC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5133039\n"); - end - xrf = 64'hC010000000000001; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h4010000000000000; - ans = 64'h4010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5133653\n"); - end - xrf = 64'hC1DFFBBFFFFFFFFE; - y = 64'h800B047A1780E566; - zrf = 64'h3CA0000000000001; - ans = 64'h3CA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5134267\n"); - end - xrf = 64'hC010000000000001; - y = 64'h8010000000000000; - zrf = 64'h43E0000003FFFFFD; - ans = 64'h43E0000003FFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5134881\n"); - end - xrf = 64'hDD5FF7DFFFFFFFFF; - y = 64'h380280ACE938A65A; - zrf = 64'hC03003BFFFFFFFFF; - ans = 64'hD5727BFA3D516EF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5135495\n"); - end - xrf = 64'h3FC0100000003FFE; + x = 64'hC00FFFFFFFFFFFFE; y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5136109\n"); - end - xrf = 64'hC010000000000001; - y = 64'hC3FE3FFFFFFFFFFF; - zrf = 64'h3FD0000080000200; - ans = 64'h441E400000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5136723\n"); - end - xrf = 64'hB7FFFFFF7FFFFFEF; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h381C3CA1A69C50A3; - ans = 64'h381C3CA1A69C50A3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5137337\n"); - end - xrf = 64'hC010000000000001; - y = 64'hB80F2AFF0007164E; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5137951\n"); - end - xrf = 64'hB7FC2F11289AB564; - y = 64'h0F40002000080000; - zrf = 64'h47EFFFFFBFFFF800; - ans = 64'h47EFFFFFBFFFF800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5138565\n"); - end - xrf = 64'hC010000000000001; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h4000000000000001; - ans = 64'h4000000000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5139179\n"); - end - xrf = 64'hC13FFFFFF0000400; - y = 64'hC090004000000040; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h41E0003FF7FFE240; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5139793\n"); - end - xrf = 64'hC010000000000001; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h002FFFEFEFFFFFFE; - ans = 64'h3CD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5140407\n"); - end - xrf = 64'h3450000010000080; - y = 64'h41492BFD6B911D35; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5141021\n"); - end - xrf = 64'h3FF68CDA81DC4085; - y = 64'hBFD0000000000001; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5141635\n"); - end - xrf = 64'hC010000000000001; - y = 64'h9550000040400000; - zrf = 64'h20A0040000003FFE; - ans = 64'h20A0040000003FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5142249\n"); - end - xrf = 64'hFFE3A84531F8840E; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h41C001FFFFFFFFFD; - ans = 64'h7FD3A84531F8840D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5142863\n"); - end - xrf = 64'hC010000000000001; - y = 64'hC14B96B6111D22AA; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'h416B96B5F11D22AC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5143477\n"); - end - xrf = 64'hBFCDDAA4207129BA; - y = 64'h43FFFFFFFBF80000; - zrf = 64'h3E00040000000000; - ans = 64'hC3DDDAA41CAE5E8D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5144091\n"); - end - xrf = 64'hC010000000000001; - y = 64'hBFE0000000000001; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h4010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5144705\n"); - end - xrf = 64'h3FF0000FFBFFFFFE; - y = 64'h4130002000001000; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h4130002FFC2007FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5145319\n"); - end - xrf = 64'hC010000000000001; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hFFD000000000E000; - ans = 64'hFFD000000000E000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5145933\n"); - end - xrf = 64'h3FDE422D7F414171; - y = 64'h480CB338797662BD; - zrf = 64'h0003FE0000000000; - ans = 64'h47FB235F6482BA69; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5146547\n"); - end - xrf = 64'hBFE7C5F1664362ED; - y = 64'hBFF0000000000000; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h40217C5F1664362E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5147161\n"); - end - xrf = 64'hC010000000000001; - y = 64'h401FFFFFFFFF807F; - zrf = 64'h1D403FFFFFFEFFFF; - ans = 64'hC03FFFFFFFFF8081; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5147775\n"); - end - xrf = 64'h3F6FFF87FFFFFFFE; - y = 64'hBFF0000000000001; - zrf = 64'h12900010000003FF; - ans = 64'hBF6FFF8800000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5148389\n"); - end - xrf = 64'hC010000000000001; - y = 64'hD4400000000803FF; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'h5460000000080400; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5149003\n"); - end - xrf = 64'hF51000407FFFFFFE; - y = 64'hC7F007FFFFFFFFFC; - zrf = 64'hC1C0A6FEA0D7127C; - ans = 64'h7D100840A03FFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5149617\n"); - end - xrf = 64'hC010000000000001; - y = 64'hC000000000000000; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h4022000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5150231\n"); - end - xrf = 64'h381D5AC938FA3977; - y = 64'hDE7F33DF488A188F; - zrf = 64'h0000000000000000; - ans = 64'hD6AC9F88731A6E52; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5150845\n"); - end - xrf = 64'hC010000000000001; - y = 64'hC000000000000001; - zrf = 64'h416FFFFEBFFFFFFE; - ans = 64'h416FFFFFBFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5151459\n"); - end - xrf = 64'h3FBBC31223632B9A; - y = 64'h800007FFFFFDFFFF; - zrf = 64'hBFFDC45F41D87D2A; - ans = 64'hBFFDC45F41D87D2A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5152073\n"); - end - xrf = 64'hC05C0000000000FF; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h4010000000000000; - ans = 64'h407C4000000000FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5152687\n"); - end - xrf = 64'hC010000000000001; - y = 64'h802FFFDFFFFFFFFE; - zrf = 64'h41DFFFFC000007FF; - ans = 64'h41DFFFFC000007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5153301\n"); - end - xrf = 64'hBCEFC00FFFFFFFFE; - y = 64'hC010000000000000; - zrf = 64'hC520400000001FFF; - ans = 64'hC520400000001FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5153915\n"); - end - xrf = 64'hC010000000000001; - y = 64'hC01FFE0000000FFF; - zrf = 64'hBFD0000000000000; - ans = 64'h403FBE0000001001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5154529\n"); - end - xrf = 64'h3F3000007FFFFEFF; - y = 64'h4080000002000000; - zrf = 64'h37E00007FFFFFF7E; - ans = 64'h3FC0000081FFFF0F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5155143\n"); - end - xrf = 64'hC010000000000001; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h3FE0000000000000; - ans = 64'h4040400000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5155757\n"); - end - xrf = 64'h400046EA12AFC890; - y = 64'hBFF00FFBFFFFFFFF; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5156371\n"); - end - xrf = 64'hC010000000000001; - y = 64'hC340000000000000; - zrf = 64'hBFB000000003FFE0; - ans = 64'h4360000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5156985\n"); - end - xrf = 64'h7FDFEDB8655EFC26; - y = 64'h001FFFFFFFFFF803; - zrf = 64'h3E50A55276CCC0F4; - ans = 64'h400FEDB867739E7C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5157599\n"); - end - xrf = 64'h41CFF7FFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h4000000000000001; - ans = 64'hC52FF7FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5158213\n"); - end - xrf = 64'hC010000000000001; - y = 64'hBFC04000000007FF; - zrf = 64'h43CFFFF7F7FFFFFF; - ans = 64'h43CFFFF7F7FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5158827\n"); - end - xrf = 64'hC0FFFF7FFFFFFFFB; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hD1FFFFFFFFF8001F; - ans = 64'hD1FFFFFFFFF8001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5159441\n"); - end - xrf = 64'hC010000000000001; - y = 64'hB0E974B62B1EEFFD; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5160055\n"); - end - xrf = 64'hD87FFFFFFE0FFFFF; - y = 64'h435FFFFFF7BFFFFF; - zrf = 64'h3F489A63D79DEF13; - ans = 64'hDBEFFFFFF5CFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5160669\n"); - end - xrf = 64'hC010000000000001; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h3FD0000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5161283\n"); - end - xrf = 64'h06D000013FFFFFFE; - y = 64'h43F0000000002002; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5161897\n"); - end - xrf = 64'hC010000000000001; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h3E9FFFFFF7BFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5162511\n"); - end - xrf = 64'h40007FFFFFBFFFFF; - y = 64'h40F0000000000FFF; - zrf = 64'h7FD00003FFFFDFFE; - ans = 64'h7FD00003FFFFDFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5163125\n"); - end - xrf = 64'h43E3A69F4ED15491; - y = 64'hFFF0000000000001; - zrf = 64'h3FFFFFFFFFFFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5163739\n"); - end - xrf = 64'hC010000000000001; - y = 64'h3FDE975AE8BCABA9; - zrf = 64'hC02FFC0200000000; - ans = 64'hC031E776AE8BCABB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5164353\n"); - end - xrf = 64'hDD17FFFFFFF7FFFF; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hA1C0000000080000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5164967\n"); - end - xrf = 64'hC010000000000001; - y = 64'h241003FFFEFFFFFE; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'hA43003FFFEFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5165581\n"); - end - xrf = 64'h4020000F7FFFFFFF; - y = 64'hBF8FBFFFEFFFFFFF; - zrf = 64'hC7EE9B8F76D93DEF; - ans = 64'hC7EE9B8F76D93DEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5166195\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h0000000000000001; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3CAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5166809\n"); - end - xrf = 64'h3C7F7FFFFFEFFFFE; - y = 64'h3160000000001FF7; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5167423\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h40000800FFFFFFFE; - ans = 64'h40000800FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5168037\n"); - end - xrf = 64'h41FD23B0B8FCEBE9; - y = 64'hC02FFF8000000800; - zrf = 64'h800FFF000007FFFF; - ans = 64'hC23D233C2A3A0F3E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5168651\n"); - end - xrf = 64'hC3E9EBC2CE66FE4D; - y = 64'h0010000000000000; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h3FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5169265\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h3FBFFFF7FFFDFFFF; - zrf = 64'h3FC0000000000084; - ans = 64'hBFEBFFF7FFFDFFDD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5169879\n"); - end - xrf = 64'hBF0FFFF0007FFFFE; - y = 64'h0010000000000001; - zrf = 64'h400FFEFFFFFF7FFE; - ans = 64'h400FFEFFFFFF7FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5170493\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hBC700007DFFFFFFF; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h3CA00007DFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5171107\n"); - end - xrf = 64'hC01FFFFFFBFE0000; - y = 64'hC0000003FFFFBFFE; - zrf = 64'hFFFFFFFFFFFBF800; - ans = 64'hFFFFFFFFFFFBF800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5171721\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h3CA0000000000000; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'hBCCFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5172335\n"); - end - xrf = 64'hC3C5E28683733451; - y = 64'hBC8FFFFFFFFFCFFF; - zrf = 64'hC340000000000000; - ans = 64'hC33FFFFFFFFFFF51; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5172949\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h3CA0000000000001; - zrf = 64'hBFFFFFFFFBFBFFFF; - ans = 64'hBFFFFFFFFBFC0003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5173563\n"); - end - xrf = 64'hF070000000FFFEFE; - y = 64'hC060000040000000; - zrf = 64'hBFDA01FD1AFA08D1; - ans = 64'h70E0000040FFFF02; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5174177\n"); - end - xrf = 64'hD8C0040000001FFF; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h3FE0000000000000; - ans = 64'hD580040000001FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5174791\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h480C4A82BDECA668; - zrf = 64'h56BFFFDFFFFBFFFF; - ans = 64'h56BFFFDFFFFBFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5175405\n"); - end - xrf = 64'hC350000210000000; - y = 64'h3FD0000000000000; - zrf = 64'hBFD3FFBFFFFFFFFF; - ans = 64'hC330000210000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5176019\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h0007FFFFFFFF0000; - zrf = 64'h8000000000000000; - ans = 64'h802FFFFFFFFBFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5176633\n"); - end - xrf = 64'h3F9C1B768C7A72FC; - y = 64'h3F5F000020000000; - zrf = 64'h3FDA8195B9525DD3; - ans = 64'h3FDA826F8E29FF64; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5177247\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h0010000000000000; - ans = 64'hC00FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5177861\n"); - end - xrf = 64'h2D80000010200000; - y = 64'h40700001FFFEFFFF; - zrf = 64'hC010000000000001; - ans = 64'hC010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5178475\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h3FE0000000000000; - zrf = 64'h5E8000100000007E; - ans = 64'h5E8000100000007E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5179089\n"); - end - xrf = 64'h15FFF7FFF0000000; - y = 64'h7FE004000FFFFFFF; - zrf = 64'h4070000003FFFF7E; - ans = 64'h55EFFFFE0FF3FFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5179703\n"); - end - xrf = 64'h40DFFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h3FD0000000000001; - ans = 64'h40E00007FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5180317\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h35C000000027FFFF; - zrf = 64'hBFFBDE4E005C85EF; - ans = 64'hBFFBDE4E005C85EF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5180931\n"); - end - xrf = 64'h3C1E000003FFFFFF; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'hC061FBFFFFFFFFFE; - ans = 64'hC061FBFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5181545\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hAB7FFF7FFFFFDFFF; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5182159\n"); - end - xrf = 64'hBFDFFEFFFFFFBFFE; - y = 64'h381FFFFFFE3FFFFE; - zrf = 64'h401FFFFFFFFBFFFF; - ans = 64'h401FFFFFFFFBFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5182773\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h0000000000000001; - ans = 64'hC02FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5183387\n"); - end - xrf = 64'h43D462244725B1D2; - y = 64'hBFCFFFFFFDFFFC00; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC3B4622445DF8D01; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5184001\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h402E000001FFFFFE; - ans = 64'hBFEFFFFFDFFFFFF0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5184615\n"); - end - xrf = 64'h80100000000020FE; - y = 64'h330003FFFFFFFFFE; - zrf = 64'hB7FFFFFFFFFBFFFE; - ans = 64'hB7FFFFFFFFFBFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5185229\n"); - end - xrf = 64'hC34FFF0001000000; - y = 64'h4000000000000001; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hC35FFF0001000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5185843\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hC18FFFFFC00007FF; - zrf = 64'h80F001DFFFFFFFFF; - ans = 64'h41BFFFFFC00007FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5186457\n"); - end - xrf = 64'hBFB000023FFFFFFE; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h43CFFFFFFFFFFA00; - ans = 64'h43CFFFFFFFFFFA00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5187071\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h391FFFBFDFFFFFFE; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5187685\n"); - end - xrf = 64'hBFB0000003FFF800; - y = 64'h400098B3FFBC4F8C; - zrf = 64'h41E01FFFFFFBFFFF; - ans = 64'h41E01FFFFFF7D9D2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5188299\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h4010000000000000; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5188913\n"); - end - xrf = 64'hBFD000001F800000; - y = 64'hBF007FFFFBFFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hBFFFFFF7BFFFF1C0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5189527\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hBB7C35D76A279BE5; - ans = 64'hC04FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5190141\n"); - end - xrf = 64'hC341C1FD8109A162; - y = 64'h47FFFF7FFFFFFEFF; - zrf = 64'h002DB8460F30FC2C; - ans = 64'hCB51C1B679139CAD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5190755\n"); - end - xrf = 64'hFFE03FE000000000; - y = 64'h4340000000000000; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5191369\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hBF500083FFFFFFFF; - zrf = 64'hC05A8A82B30454FB; - ans = 64'hC05A8A02AEE454FB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5191983\n"); - end - xrf = 64'hBFAFFFFFFFFFFFFF; - y = 64'h4340000000000001; - zrf = 64'h380FBFFFFFFFDFFE; - ans = 64'hC300000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5192597\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hBFC08000000FFFFF; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5193211\n"); - end - xrf = 64'hFFE3167174D6CD3D; - y = 64'hC80000008000001E; - zrf = 64'h3FBBFFFFFFFFDFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5193825\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5194439\n"); - end - xrf = 64'hBFAE000FFFFFFFFF; - y = 64'h47ED198E0C823F11; - zrf = 64'hBFF0000000000000; - ans = 64'hC7AB4803B8812160; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5195053\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h7FE0000000000001; - zrf = 64'h3800FFFFFFFFFFDF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5195667\n"); - end - xrf = 64'h414FC0003FFFFFFF; - y = 64'h43C2129B0DB38A30; - zrf = 64'hFFDFFF7FFFFFBFFE; - ans = 64'hFFDFFF7FFFFFBFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5196281\n"); - end - xrf = 64'h4050000800000040; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h0010000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5196895\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hBFEFFFFFFFDF0000; - zrf = 64'h402040003FFFFFFF; - ans = 64'h403020001FF7BFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5197509\n"); - end - xrf = 64'hC340004000007FFE; - y = 64'h7FF0000000000000; - zrf = 64'hC3E0001400000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5198123\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hC74FFFE000010000; - zrf = 64'h4340000000000000; - ans = 64'h477FFFE00000FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5198737\n"); - end - xrf = 64'h3FBC00000000007E; - y = 64'h7F957BABBD0DE162; - zrf = 64'h41A23326F564D672; - ans = 64'h7F62CC36456C258A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5199351\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'hFFE0000000000000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5199965\n"); - end - xrf = 64'hC346FFFFFFFFFFFF; - y = 64'h3ACF000000003FFF; - zrf = 64'hBFE0000000000001; - ans = 64'hBFE0000001648001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5200579\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h8000000000000000; - zrf = 64'hBFDFFBFFFFFFFFC0; - ans = 64'hBFDFFBFFFFFFFFC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5201193\n"); - end - xrf = 64'h357FFE0003FFFFFF; - y = 64'hB810000000400010; - zrf = 64'h3FDBFFF800000000; - ans = 64'h3FDBFFF800000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5201807\n"); - end - xrf = 64'h2C94AE4C0BE00BB9; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h0000000000000001; - ans = 64'h0000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5202421\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hC1600000003FFFDF; - zrf = 64'hCB5F800000000000; - ans = 64'hCB5F800000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5203035\n"); - end - xrf = 64'hC0CFFF7FFBFFFFFF; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h107FFF7FFF7FFFFF; - ans = 64'h107FFF7FFF7FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5203649\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h3DA00001FFFEFFFE; - zrf = 64'h4010000000000001; - ans = 64'h400FFFFFFFFE0002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5204263\n"); - end - xrf = 64'h3CB519C3F65131B3; - y = 64'h34411857FBC3E3FD; - zrf = 64'hC02FFFC00000001F; - ans = 64'hC02FFFC00000001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5204877\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h8010000000000001; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5205491\n"); - end - xrf = 64'h3FB64CC4656E6744; - y = 64'h8420000100000007; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5206105\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h4000000003FFFFFE; - ans = 64'h4000000003FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5206719\n"); - end - xrf = 64'hBFC00000000100FF; - y = 64'h6F8AF2A912200C95; - zrf = 64'h4030000010000010; - ans = 64'hEF5AF2A91221BD6D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5207333\n"); - end - xrf = 64'h3FD0FBFFFFFFFFFF; - y = 64'hBCA0000000000000; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5207947\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hBFCFFFBFFFF7FFFF; - zrf = 64'hFFDEFFFFFFFFFFF7; - ans = 64'hFFDEFFFFFFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5208561\n"); - end - xrf = 64'hC80000800001FFFF; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h7E403FFFFFFFEFFF; - ans = 64'h7E403FFFFFFFEFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5209175\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hBF7000007FBFFFFF; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h4010200000FF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5209789\n"); - end - xrf = 64'hBFFFFFFFFFFFF7BE; - y = 64'h3FEBFFFFFFFF7FFF; - zrf = 64'hC80FFFFDFFFFFF00; - ans = 64'hC80FFFFDFFFFFF00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5210403\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hBFD0000000000000; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC017FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5211017\n"); - end - xrf = 64'h3DDFFE0FFFFFFFFF; - y = 64'h5DBFFFFFFC000400; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'h5BAFFE0FFC0041FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5211631\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h481000000004003F; - ans = 64'h481000000004003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5212245\n"); - end - xrf = 64'hC7EFFFF7FFF7FFFF; - y = 64'hBFE00000002003FE; - zrf = 64'hDE6FFFFFFFFFFEF7; - ans = 64'hDE6FFFFFFFFFFEF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5212859\n"); - end - xrf = 64'h5407FFFFFDFFFFFE; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5213473\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hC3F7EB0F3250B56F; - zrf = 64'h3FB9C5049037358D; - ans = 64'h4427EB0F3250B56E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5214087\n"); - end - xrf = 64'hC3D007FFFFFF7FFF; - y = 64'hBFE0000000000001; - zrf = 64'h41FFFFFFFFFFFFFE; - ans = 64'h43C0080000FF8000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5214701\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h3FEF7FFEFFFFFFFE; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'hC0177FFEFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5215315\n"); - end - xrf = 64'h3FD8000000FFFFFE; - y = 64'hC3D0000000000000; - zrf = 64'hBFC00000007FFC00; - ans = 64'hC3B8000000FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5215929\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5216543\n"); - end - xrf = 64'h3FD676B0A3035D2E; - y = 64'hC000B69CD7D0E245; - zrf = 64'hBCA0000000000000; - ans = 64'hBFE77712F07C0308; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5217157\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hBFF0000000000001; - zrf = 64'hC617FFFFFFFF8000; - ans = 64'hC617FFFFFFFF8000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5217771\n"); - end - xrf = 64'hC34C5B5FDC3B3FD2; - y = 64'hC7FFFFFFFFC03FFF; - zrf = 64'hC000000040000100; - ans = 64'h4B5C5B5FDC02C1C8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5218385\n"); - end - xrf = 64'hBD4FC000000001FE; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5218999\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h480000000003FFBF; - zrf = 64'hC3D069FA6E030EDC; - ans = 64'hC83000000003FFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5219613\n"); - end - xrf = 64'h4793FFFEFFFFFFFF; - y = 64'hC000000000000000; - zrf = 64'h4050E00000000000; - ans = 64'hC7A3FFFEFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5220227\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h40B0000002003FFE; - zrf = 64'h3FF0000000000000; - ans = 64'hC0DFFFC004007FFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5220841\n"); - end - xrf = 64'hC150C1B6ED20CDB4; - y = 64'hC80FFFFF7FFFF800; - zrf = 64'h378A486E49A40B33; - ans = 64'h4970C1B6AA19EDCF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5221455\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'hC000000000000000; - ans = 64'h403DFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5222069\n"); - end - xrf = 64'h400FFFFFF81FFFFF; - y = 64'h3B60100000000007; - zrf = 64'h8010000000000001; - ans = 64'h3B800FFFFC0C1006; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5222683\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hC010000000000000; - zrf = 64'hBA0FFFFFFFFC7FFF; - ans = 64'h403FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5223297\n"); - end - xrf = 64'h7FDB2F35318EC64C; - y = 64'h434F000007FFFFFF; - zrf = 64'h434FFFFFFFFFF801; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5223911\n"); - end - xrf = 64'h41FFFFFE00200000; - y = 64'hC010000000000001; - zrf = 64'hC340000000000001; - ans = 64'hC3400003FFFFC005; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5224525\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hC3DFA327D4E0C570; - zrf = 64'h405A841B0E622CBB; - ans = 64'h440FA327D4E0C56F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5225139\n"); - end - xrf = 64'h304FFFFFFDF7FFFE; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h7FDFFFFEFC000000; - ans = 64'h7FDFFFFEFC000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5225753\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hBFD1D8406D2830A9; - zrf = 64'h3FE0000000000001; - ans = 64'h4005D8406D2830A9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5226367\n"); - end - xrf = 64'hB8100000DFFFFFFE; - y = 64'hACF0008000FFFFFF; - zrf = 64'h800FFFFBFFFF0000; - ans = 64'h25100080E107000B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5226981\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hC340000000000001; - zrf = 64'hBFF0000000000001; - ans = 64'h4370000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5227595\n"); - end - xrf = 64'h481000000800000F; - y = 64'hB9A00000001FF7FF; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'hC1C00000081FF80E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5228209\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hB7EFFE1FFFFFFFFE; - ans = 64'h437FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5228823\n"); - end - xrf = 64'h39EFB9C6341C50C5; - y = 64'hBE68594769A877A8; - zrf = 64'hC0E0000400000004; - ans = 64'hC0E0000400000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5229437\n"); - end - xrf = 64'h4EEE000000000200; - y = 64'hFFE0000000000000; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5230051\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h0ED0000010001FFF; - zrf = 64'hBF808003FFFFFFFF; - ans = 64'hBF808003FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5230665\n"); - end - xrf = 64'hC01FFFFFF000001E; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h3E5FFFFFC0000100; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5231279\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'h74E737367C565875; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'hF51737367C565874; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5231893\n"); - end - xrf = 64'h3680FFDFFFFFFFFE; - y = 64'h38AE0000000001FE; - zrf = 64'hBFB03FFFF7FFFFFE; - ans = 64'hBFB03FFFF7FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5232507\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hFFF0000000000000; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5233121\n"); - end - xrf = 64'hBF100000FFF80000; - y = 64'h3ECDFFFFFBFFFFFE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5233735\n"); - end - xrf = 64'hC01FFFFFFFFFFFFF; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hC02FB4CAEFE668FD; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5234349\n"); - end - xrf = 64'h402FFB7FFFFFFFFE; - y = 64'hC34FFFF83FFFFFFF; - zrf = 64'h8006AFFFBE6D51F6; - ans = 64'hC38FFB784116FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5234963\n"); - end - xrf = 64'hC7F1852BE7D131B7; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'hC00FFFFFFFFFFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5235577\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h3FC2C2817E493F67; - zrf = 64'h3C300000001FFFFF; - ans = 64'hBFF2C2817E493F66; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5236191\n"); - end - xrf = 64'hBFF00000FFFFFFFF; - y = 64'h0000000000000001; - zrf = 64'h78B8B3C6E6297A3F; - ans = 64'h78B8B3C6E6297A3F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5236805\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h41D010000000003F; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'hC20010000000003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5237419\n"); - end - xrf = 64'hBE58BC66C60747BE; - y = 64'hFFDFFFFFFFC03FFE; - zrf = 64'h4C6B4DBF4516173A; - ans = 64'h7E48BC66C5D60068; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5238033\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5238647\n"); - end - xrf = 64'hBF000401FFFFFFFE; - y = 64'hC1CF003FFFFFFFFE; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5239261\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h0010000000000001; - zrf = 64'h3B28000000000006; - ans = 64'h3B28000000000006; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5239875\n"); - end - xrf = 64'h0000001000003FFE; - y = 64'hC48801FFFFFFFFFE; - zrf = 64'h4020000000000EFE; - ans = 64'h4020000000000EFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5240489\n"); - end - xrf = 64'hC050007FFFFDFFFF; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hC000000000000000; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5241103\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hFFE0000000200007; - zrf = 64'hC1D0000000380000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5241717\n"); - end - xrf = 64'hC7F03FFFFFFDFFFF; - y = 64'h3CA0000000000000; - zrf = 64'hB81337DCA9B15B66; - ans = 64'hC4A03FFFFFFDFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5242331\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h800000007DFFFFFF; - zrf = 64'h3CA0000000000000; - ans = 64'h3CA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5242945\n"); - end - xrf = 64'h3FFC01FFFFFFFFFF; - y = 64'h6C14E26562BDB07E; - zrf = 64'hC8018D68DABD1F6C; - ans = 64'h6C224766DCBC2649; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5243559\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hBFD0000000000000; - ans = 64'hBFD0000000000020; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5244173\n"); - end - xrf = 64'h402A460B799C0E9B; - y = 64'hC0900000003FFFFF; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5244787\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h3FD0000000000000; - zrf = 64'h373007FFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5245401\n"); - end - xrf = 64'hA16FFFF000100000; - y = 64'h7FDFFFFBFFF7FFFE; - zrf = 64'hC0D1007FFFFFFFFE; - ans = 64'hE15FFFEC000A0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5246015\n"); - end - xrf = 64'hC7F0008FFFFFFFFF; - y = 64'h3FD0000000000001; - zrf = 64'hBFF0000000000001; - ans = 64'hC7D0009000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5246629\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hBFC0000820000000; - zrf = 64'hFFD000010001FFFE; - ans = 64'hFFD000010001FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5247243\n"); - end - xrf = 64'hCFF0000000FFFFE0; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'hC1E00001FFFEFFFF; - ans = 64'hCFE0000000FFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5247857\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hCFDFFC0000800000; - zrf = 64'h0010000000000001; - ans = 64'h500FFC00007FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5248471\n"); - end - xrf = 64'h43B4E0E29C65A9DF; - y = 64'hB80FFF800001FFFF; - zrf = 64'hC3D007FFFFFE0000; - ans = 64'hC3D007FFFFFE0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5249085\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h3FE0000000000001; - zrf = 64'hBCA0000000000001; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5249699\n"); - end - xrf = 64'hFFE00003FFFF0000; - y = 64'hB819EC548BD15151; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h7809EC5B06E4D580; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5250313\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h801FFFFFFBFFFBFF; - ans = 64'hC01FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5250927\n"); - end - xrf = 64'h3FCFF7FFFDFFFFFE; - y = 64'hBFF000000001FFFF; - zrf = 64'hC0C02000000001FE; - ans = 64'hC0C0201FF8000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5251541\n"); - end - xrf = 64'h403FE0000001FFFE; - y = 64'h3FF0000000000000; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'h403EE0000001FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5252155\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h0023FFFFFFFFFFF0; - zrf = 64'hB7E00040001FFFFF; - ans = 64'hB7E00040001FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5252769\n"); - end - xrf = 64'h40FF501F559B867D; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h9F4FFFFFFBFFFFF7; - ans = 64'h410F501F559B867C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5253383\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hC2800000000FFFF0; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h42B00000000FFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5253997\n"); - end - xrf = 64'h3FDFFFFFFFFFF0FE; - y = 64'h3F8FFFDFFFFFFFDF; - zrf = 64'h40557EDE4248928B; - ans = 64'h40557F5E41C8928B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5254611\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h4000000000000000; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'hC02FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5255225\n"); - end - xrf = 64'hBFF0000040000001; - y = 64'h402474240CF89EBE; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'hC001D0917B24BBD1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5255839\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hFFD022B73EDDB4E3; - ans = 64'hFFD022B73EDDB4E3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5256453\n"); - end - xrf = 64'hC1EC00000000007E; - y = 64'hDB4000000000083E; - zrf = 64'hC01003C000000000; - ans = 64'h5D3C000000000EEB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5257067\n"); - end - xrf = 64'h3CA151417F125FDD; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFF5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5257681\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h3FD0001FFFFFF7FF; - zrf = 64'hFFF000000FFFFEFE; - ans = 64'hFFF800000FFFFEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5258295\n"); - end - xrf = 64'h5A5FFFE00000001F; - y = 64'h4010000000000001; - zrf = 64'h3FF78D25A2611BAA; - ans = 64'h5A7FFFE000000021; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5258909\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hC1E00407FFFFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5259523\n"); - end - xrf = 64'hC1E0000000000000; - y = 64'h415FBDFFFFFFFFFF; - zrf = 64'h210FFFE07FFFFFFF; - ans = 64'hC34FBDFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5260137\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hC04FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5260751\n"); - end - xrf = 64'h8DDFF003FFFFFFFF; - y = 64'hC63DDFFFFFFFFFFF; - zrf = 64'h4010000000000000; - ans = 64'h4010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5261365\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h4340000000000001; - zrf = 64'hC0C4B2646EB257A1; - ans = 64'hC370000000000296; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5261979\n"); - end - xrf = 64'hC1E0000000020001; - y = 64'h0020000000003DFF; - zrf = 64'h434FFFFFF8003FFE; - ans = 64'h434FFFFFF8003FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5262593\n"); - end - xrf = 64'h4028000001FFFFFF; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'hBFD0000000000000; - ans = 64'h4388000001FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5263207\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hC03F8003FFFFFFFF; - zrf = 64'h000FFFFFFFBFFFEF; - ans = 64'h406F8003FFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5263821\n"); - end - xrf = 64'hC3C000040000000F; - y = 64'h7FE0000000000000; - zrf = 64'hF0B1FFFFFFFFFF80; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5264435\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hA2B0000002000007; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5265049\n"); - end - xrf = 64'h3810000044000000; - y = 64'h4F8000000017FFFF; - zrf = 64'h41C06FFFFFFFFFFF; - ans = 64'h47A000004417FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5265663\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h8000000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5266277\n"); - end - xrf = 64'hC1E00000004001FF; - y = 64'hC7FFFFFBFEFFFFFF; - zrf = 64'h4000000000000001; - ans = 64'h49EFFFFBFF8003ED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5266891\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h7FF0000000000000; - zrf = 64'h43E00003FFFFFFEE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5267505\n"); - end - xrf = 64'h6430007FFFF7FFFF; - y = 64'hB80FFFF0FFFFFFFF; - zrf = 64'hBFC8CFCB605F09CF; - ans = 64'hDC5000787FBC0002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5268119\n"); - end - xrf = 64'h7FF200000000003F; - y = 64'h7FF0000000000001; - zrf = 64'hBCA0000000000001; - ans = 64'h7FFA00000000003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5268733\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h47E4000003FFFFFE; - zrf = 64'h56E0487D8AA1BB24; - ans = 64'h56E0487D8AA1BB24; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5269347\n"); - end - xrf = 64'h4F2F48F56D7129D8; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'hC3CFFFFC1FFFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5269961\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h7FDFAA6E1C1878D5; - zrf = 64'hFFE0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5270575\n"); - end - xrf = 64'h203BFFFFFFFFBFFF; - y = 64'h002FFFF8003FFFFF; - zrf = 64'h3FF0000001FFFFF8; - ans = 64'h3FF0000001FFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5271189\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h8000000000000001; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5271803\n"); - end - xrf = 64'h3FC002FFFFFFFFFE; - y = 64'h7FEDA17BCE63B7B9; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h7FBDA70A159A6A68; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5272417\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'hFFD000000000FBFE; - ans = 64'hFFD000000000FBFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5273031\n"); - end - xrf = 64'h330FFFFF7FFFFFDF; - y = 64'h7FD000000000080E; - zrf = 64'h43EFFFF000003FFE; - ans = 64'h72EFFFFF80000FFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5273645\n"); - end - xrf = 64'hFFDFFFFFFBFFFFFA; - y = 64'h8010000000000000; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFBFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5274259\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h3FBFDFFFBFFFFFFF; - zrf = 64'hFFDFFFFFFFEFBFFF; - ans = 64'hFFDFFFFFFFEFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5274873\n"); - end - xrf = 64'hE8BFFFFFC0000002; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h38100001FE000000; - ans = 64'h38100001FE000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5275487\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h4116A25041EC6F21; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC3500000000B5128; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5276101\n"); - end - xrf = 64'h43C329209FCEBD7A; - y = 64'h403706C195DA682C; - zrf = 64'hC71FFFFFFFEFFDFF; - ans = 64'hC71FFFFFFFEFFDF1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5276715\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hBCA0000000000000; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5277329\n"); - end - xrf = 64'hC61FFFFFFBFFDFFF; - y = 64'h3F8E7ADE3D9DF495; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'hC5BE7ADE39CE7A51; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5277943\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hBCA0000000000001; - zrf = 64'hC02FFFFFFFFFFE07; - ans = 64'hC02FFFFFFFFFFE07; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5278557\n"); - end - xrf = 64'h3AFFFFFFFFFFCFFF; - y = 64'hBE9FC00080000000; - zrf = 64'hFFE00007FFFFFFFF; - ans = 64'hFFE00007FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5279171\n"); - end - xrf = 64'hC3EFFFFFFFFFFDFE; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h40AFFFFFFFFFFDFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5279785\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h47EFFFFFFFFFFFFE; - zrf = 64'h8010000000024000; - ans = 64'hC81FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5280399\n"); - end - xrf = 64'hC12FFFEFFFFFFFFA; - y = 64'hBFD0000000000001; - zrf = 64'hA031728DE85DC67B; - ans = 64'h410FFFEFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5281013\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h6B3FFFFFE000FFFF; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hEB6FFFFFE000FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5281627\n"); - end - xrf = 64'hB7EFFFFFEFBFFFFF; - y = 64'hBFEFFBFFFFEFFFFF; - zrf = 64'h5BBD3E8F7C7B83DC; - ans = 64'h5BBD3E8F7C7B83DC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5282241\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h4350000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5282855\n"); - end - xrf = 64'h403FA3D7E0B0298E; - y = 64'hC1DC875A6EB3E6DC; - zrf = 64'h3FE0000000000000; - ans = 64'hC22C353185994A52; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5283469\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hBFE0000000000000; - zrf = 64'h801FFF7FFFFFFFF7; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5284083\n"); - end - xrf = 64'hC1DFFF8400000000; - y = 64'hBE10DE512C1E4FF2; - zrf = 64'h7FDA6E477FE2FB9F; - ans = 64'h7FDA6E477FE2FB9F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5284697\n"); - end - xrf = 64'h1C239A7AD4673D5C; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h8000000000000000; - ans = 64'h9C239A7AD4673D5B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5285311\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hBFE8010000000000; - zrf = 64'hB7F1FFFFFFFFEFFE; - ans = 64'h401800FFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5285925\n"); - end - xrf = 64'h51B000003F7FFFFE; - y = 64'hBFF0000000000000; - zrf = 64'h3FFFFFC000200000; - ans = 64'hD1B000003F7FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5286539\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hC01FE0FFFFFFFFFF; - zrf = 64'hC010000000000000; - ans = 64'h404DE0FFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5287153\n"); - end - xrf = 64'h3F6FFFDFF8000000; - y = 64'hC070012000000000; - zrf = 64'h43E803645D7EE7FE; - ans = 64'h43E803645D7EE7FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5287767\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h4340000000000000; - ans = 64'h4340000000000008; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5288381\n"); - end - xrf = 64'h3CA00000080000FF; - y = 64'hC03BA4A52C2417D4; - zrf = 64'h3FD0000000000001; - ans = 64'h3FCFFFFFFFFFFF93; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5288995\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h4001FFFFFFF7FFFF; - ans = 64'h40323FFFFFFEFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5289609\n"); - end - xrf = 64'hC7F00006FFFFFFFE; - y = 64'h400B44AF91E7AA40; - zrf = 64'hFFD48598C862BB0B; - ans = 64'hFFD48598C862BB0B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5290223\n"); - end - xrf = 64'h3EE020000000FFFF; - y = 64'hC000000000000001; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5290837\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hC3E0000000000060; - zrf = 64'h3FDFFC00003FFFFF; - ans = 64'h441000000000005F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5291451\n"); - end - xrf = 64'h00217AD4EE4D5DC3; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h3FFDFCF86036943B; - ans = 64'h3FFDFCF86036943B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5292065\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h41E8000000000000; - zrf = 64'hC000000000000001; - ans = 64'hC21800000007FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5292679\n"); - end - xrf = 64'h00153CCF94A27622; - y = 64'h47FF911A44D334F9; - zrf = 64'h3E9000000200003F; - ans = 64'h3E9000000200003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5293293\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hC010000000000001; - zrf = 64'h4010000000000001; - ans = 64'h4042000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5293907\n"); - end - xrf = 64'hC0D0007FFFFFFFFA; - y = 64'hBCA003F7FFFFFFFE; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h3D8004F81FBFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5294521\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h3FBFFF7FFFFFFE00; - ans = 64'h405007FFDFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5295135\n"); - end - xrf = 64'h403FFFFFFFBFFC00; - y = 64'h314FFFFFFFFF03FF; - zrf = 64'hC3F0001FFFFDFFFF; - ans = 64'hC3F0001FFFFDFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5295749\n"); - end - xrf = 64'hB7FFFFFFFF7FFF7E; - y = 64'hC340000000000000; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5296363\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hC7F0FFFFFBFFFFFF; - zrf = 64'h3EDFFFFBFFFFFFF0; - ans = 64'h4820FFFFFBFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5296977\n"); - end - xrf = 64'hC2D00007FFFFFFF6; - y = 64'hC340000000000001; - zrf = 64'h4017DA8D7AE241C1; - ans = 64'h46200007FFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5297591\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h480935F5E7857892; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hC83935F5E7857890; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5298205\n"); - end - xrf = 64'h7FF3DC36F42A6CB4; - y = 64'h452FFFEFFFEFFFFF; - zrf = 64'h3FC000000400001F; - ans = 64'h7FFBDC36F42A6CB4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5298819\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hFFE0000000000000; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5299433\n"); - end - xrf = 64'h801C040000000000; - y = 64'h3500000000003F7F; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h001FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5300047\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hFFE0000000000001; - zrf = 64'hF13FFFFFFF801FFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5300661\n"); - end - xrf = 64'h3F4020003FFFFFFF; - y = 64'hC7E0000080008000; - zrf = 64'h3E3003FFFE000000; - ans = 64'hC7302000C10082FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5301275\n"); - end - xrf = 64'hC7E0000001000008; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5301889\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'h67DFF00001FFFFFE; - zrf = 64'h381889513EAF6034; - ans = 64'hE80FF00001FFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5302503\n"); - end - xrf = 64'h3CCA01EEDB1F8B06; - y = 64'hFFF0000000000000; - zrf = 64'h62000000000040FF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5303117\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hBFEFFF0000003FFE; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'h401BFF0000003FFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5303731\n"); - end - xrf = 64'h403FFFFFFFFFC3FE; - y = 64'h3FB010007FFFFFFE; - zrf = 64'h40207FFFFFEFFFFF; - ans = 64'h402484001FEFF877; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5304345\n"); - end - xrf = 64'hC01FFFFFFFFFFFFE; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h3FFFFFFFFFFFFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5304959\n"); - end - xrf = 64'h3F8000000000002E; - y = 64'hC1FFFFFFFF1FFFFF; - zrf = 64'h0010000000000000; - ans = 64'hC18FFFFFFF20005B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5305573\n"); - end - xrf = 64'hC340000000000000; - y = 64'h0000000000000000; - zrf = 64'h002FFFFFFFFFFFEE; - ans = 64'h002FFFFFFFFFFFEE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5306187\n"); - end - xrf = 64'h42EC763F6A91F223; - y = 64'hBDEFFBFEFFFFFFFE; - zrf = 64'hBF00000220000000; - ans = 64'hC0EC72AFBF32A497; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5306801\n"); - end - xrf = 64'h8026C06299DDB88B; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5307415\n"); - end - xrf = 64'hC340000000000000; - y = 64'h000000400000FFFE; - zrf = 64'h43CFFFFFFFFF7FC0; - ans = 64'h43CFFFFFFFFF7FC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5308029\n"); - end - xrf = 64'h31DBABB9341FB178; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h000FF80003FFFFFF; - ans = 64'h000FF80003FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5308643\n"); - end - xrf = 64'hC340000000000000; - y = 64'hC3F36AB50AA51D0E; - zrf = 64'hBFE0000000000000; - ans = 64'h47436AB50AA51D0E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5309257\n"); - end - xrf = 64'hC02000000040007F; - y = 64'hCC5FFFFFFFC001FE; - zrf = 64'h3FBFFF800007FFFF; - ans = 64'h4C9000000020017E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5309871\n"); - end - xrf = 64'hC340000000000000; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h3FF0000000000000; - ans = 64'h3FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5310485\n"); - end - xrf = 64'hBEE9B07DFC94527E; - y = 64'hC3DFFFFFBFBFFFFF; - zrf = 64'h0000000000000001; - ans = 64'h42D9B07DC8FFF588; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5311099\n"); - end - xrf = 64'hC340000000000000; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hB5DFFFFFFF7FFFC0; - ans = 64'hB5DFFFFFFF7FFFC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5311713\n"); - end - xrf = 64'hBFB3F6869FA94ECD; - y = 64'h11FFFFFEFFEFFFFF; - zrf = 64'hBFC8C1C0B01B17D1; - ans = 64'hBFC8C1C0B01B17D1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5312327\n"); - end - xrf = 64'hC34FFFFC00002000; - y = 64'h3CA0000000000001; - zrf = 64'h4010000000000001; - ans = 64'h40000001FFFFF001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5312941\n"); - end - xrf = 64'hC340000000000000; - y = 64'h43C0000001FFFFFE; - zrf = 64'h801906194BFF8817; - ans = 64'hC710000001FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5313555\n"); - end - xrf = 64'hC3C499CD7824B982; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hC4D000000007DFFE; - ans = 64'hC4D000000007DFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5314169\n"); - end - xrf = 64'hC340000000000000; - y = 64'hF520001FBFFFFFFF; - zrf = 64'hBFD0000000000001; - ans = 64'h7870001FBFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5314783\n"); - end - xrf = 64'h402FF00000FFFFFF; - y = 64'hC0222C1DE6737E58; - zrf = 64'hC19FFFFFE00001FF; - ans = 64'hC1A0000112307E81; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5315397\n"); - end - xrf = 64'hC340000000000000; - y = 64'h3FD0000000000001; - zrf = 64'h3FE0000000000001; - ans = 64'hC320000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5316011\n"); - end - xrf = 64'h3F7FFC3FFFFFFFFF; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5316625\n"); - end - xrf = 64'hC340000000000000; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hC23233B37BC31251; - ans = 64'hC330001233B37BC3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5317239\n"); - end - xrf = 64'h4010000007FFFBFE; - y = 64'h37EFFFFC00000010; - zrf = 64'h37F4000000800000; - ans = 64'h3814FFFE081FFB06; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5317853\n"); - end - xrf = 64'hC3FF689B685F7401; - y = 64'h3FE0000000000000; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'hC3EF689B685F7401; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5318467\n"); - end - xrf = 64'hC340000000000000; - y = 64'hBFC00020000000FF; - zrf = 64'hBFF0000000100002; - ans = 64'h43100020000000FB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5319081\n"); - end - xrf = 64'h280FFFFFFFFFFEF6; - y = 64'h3FE0000000000001; - zrf = 64'h480FFFF80003FFFE; - ans = 64'h480FFFF80003FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5319695\n"); - end - xrf = 64'hC340000000000000; - y = 64'hB1FA6E427F32FECB; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5320309\n"); - end - xrf = 64'h406D3189E59B49E6; - y = 64'hC01000007FFDFFFF; - zrf = 64'hBFD802CE726B76C7; - ans = 64'hC08D348B28F2404F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5320923\n"); - end - xrf = 64'hC340000000000000; - y = 64'h3FF0000000000000; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5321537\n"); - end - xrf = 64'hBF4F800FFFFFFFFF; - y = 64'h8020000080040000; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5322151\n"); - end - xrf = 64'hC340000000000000; - y = 64'h3FF0000000000001; - zrf = 64'h40DFFDFFFFF7FFFF; - ans = 64'hC33FFFFFFFFF800A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5322765\n"); - end - xrf = 64'h3FE000401FFFFFFE; - y = 64'h7BAFF03FFFFFFFFE; - zrf = 64'hC3DFFFE003FFFFFE; - ans = 64'h7B9FF0C000E07FFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5323379\n"); - end - xrf = 64'h40100007F0000000; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h40240007EFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5323993\n"); - end - xrf = 64'hC340000000000000; - y = 64'hC3C00000000FFE00; - zrf = 64'h3C1E4B74489750F2; - ans = 64'h47100000000FFE00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5324607\n"); - end - xrf = 64'hC7EBFFFFE0000000; - y = 64'h4000000000000000; - zrf = 64'h487FFFFFFFF03FFE; - ans = 64'h487FE40000103FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5325221\n"); - end - xrf = 64'hC340000000000000; - y = 64'hC26000001000007E; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h45B000001000007E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5325835\n"); - end - xrf = 64'h43EFFFFFDFFF8000; - y = 64'h43D0EF171F47F615; - zrf = 64'hC430FFFFFFFFFFBF; - ans = 64'h47D0EF170E589B39; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5326449\n"); - end - xrf = 64'hC340000000000000; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'hC35FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5327063\n"); - end - xrf = 64'h3D77403F0BF0CA91; - y = 64'h303000100000003F; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5327677\n"); - end - xrf = 64'hC340000000000000; - y = 64'h4010000000000000; - zrf = 64'h405FFFFFFFFFFBBF; - ans = 64'hC35FFFFFFFFFFFE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5328291\n"); - end - xrf = 64'hC062E2C7AA922DEA; - y = 64'h3DA0003FFFDFFFFF; - zrf = 64'h432C000000000004; - ans = 64'h432C000000000004; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5328905\n"); - end - xrf = 64'hBCA0080000FFFFFE; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h3FF0000000000000; - ans = 64'h3FEFFFFFFFFFFFF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5329519\n"); - end - xrf = 64'hC340000000000000; - y = 64'h402000007FFFE000; - zrf = 64'hB8000000000203FE; - ans = 64'hC37000007FFFE000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5330133\n"); - end - xrf = 64'hEE4FFFFF800003FE; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hCF30001200000000; - ans = 64'hEE7FFFFF800003FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5330747\n"); - end - xrf = 64'hC340000000000000; - y = 64'hBD3FEFFFFFFFFFFF; - zrf = 64'h8010000000000000; - ans = 64'h408FEFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5331361\n"); - end - xrf = 64'h3F80007FFFFFFFFE; - y = 64'hC02000000FFFBFFE; - zrf = 64'h405034FDFFE069AF; - ans = 64'h405030FDDFDC699F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5331975\n"); - end - xrf = 64'hC340000000000000; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h3CA0000000000000; - ans = 64'hC69FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5332589\n"); - end - xrf = 64'hBFBBF5A32582712E; - y = 64'h4000000003FFFFE0; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5333203\n"); - end - xrf = 64'hC340000000000000; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h3FB000000001FF7F; - ans = 64'hC69FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5333817\n"); - end - xrf = 64'h37E0007DFFFFFFFE; - y = 64'hC1CFFFF7FFFFFFFE; - zrf = 64'hC1F0000002000100; - ans = 64'hC1F0000002000100; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5334431\n"); - end - xrf = 64'hFFE5C73B0CF291CA; - y = 64'h7FE0000000000001; - zrf = 64'h3FE0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5335045\n"); - end - xrf = 64'hC340000000000000; - y = 64'h801FBF7FFFFFFFFF; - zrf = 64'h3F8FFD7FFFFFFFFF; - ans = 64'h3F8FFD7FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5335659\n"); - end - xrf = 64'hC800020000800000; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h41EAD159726D027F; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5336273\n"); - end - xrf = 64'hC340000000000000; - y = 64'h45FBE7961CC9DE67; - zrf = 64'h8000000000000001; - ans = 64'hC94BE7961CC9DE67; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5336887\n"); - end - xrf = 64'h413FFFFC0000001E; - y = 64'hC80007FFFFDFFFFF; - zrf = 64'h402518D974281805; - ans = 64'hC95007FDFEE00012; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5337501\n"); - end - xrf = 64'hC340000000000000; - y = 64'h7FF0000000000001; - zrf = 64'h0010000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5338115\n"); - end - xrf = 64'h37EA376D0CDA0550; - y = 64'hBFC1000000000000; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'hC01FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5338729\n"); - end - xrf = 64'hC340000000000000; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h434EBBC79281E315; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5339343\n"); - end - xrf = 64'h1D50000F00000000; - y = 64'h0023AC7CE631EB2A; - zrf = 64'h47EFFFF0000007FF; - ans = 64'h47EFFFF0000007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5339957\n"); - end - xrf = 64'hC3CFFFFFFF000000; - y = 64'h8000000000000000; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5340571\n"); - end - xrf = 64'hC340000000000000; - y = 64'hBCEFDFFFFFFFF800; - zrf = 64'h47E0000803FFFFFF; - ans = 64'h47E0000803FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5341185\n"); - end - xrf = 64'h3801FFFFFFFFFF7E; - y = 64'h8000000000000001; - zrf = 64'h001705D2EBB8BAE6; - ans = 64'h001705D2EBB8BAE6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5341799\n"); - end - xrf = 64'hC340000000000000; - y = 64'hC00FFFFF80000000; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5342413\n"); - end - xrf = 64'hC1E00000000003FF; - y = 64'hC01FFFFFC0007FFE; - zrf = 64'h480812D5C7ED1863; - ans = 64'h480812D5C7ED1863; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5343027\n"); - end - xrf = 64'hC340000000000000; - y = 64'h8010000000000000; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h0360000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5343641\n"); - end - xrf = 64'h0028000000000400; - y = 64'hC03FFE0040000000; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5344255\n"); - end - xrf = 64'hC340000000000000; - y = 64'h8010000000000001; - zrf = 64'hDF5FFFFFE1FFFFFE; - ans = 64'hDF5FFFFFE1FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5344869\n"); - end - xrf = 64'hC900000000000009; - y = 64'h40068F2DBFA560FE; - zrf = 64'h7FE0400000002000; - ans = 64'h7FE0400000002000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5345483\n"); - end - xrf = 64'hA06FFFFFFDFFFBFF; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h3CAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5346097\n"); - end - xrf = 64'hC340000000000000; - y = 64'h7A300000BFFFFFFF; - zrf = 64'h402000003FF00000; - ans = 64'hFD800000BFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5346711\n"); - end - xrf = 64'h38000200000001FE; - y = 64'hBCA0000000000000; - zrf = 64'hA4E0000400000000; - ans = 64'hB4B00200000001FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5347325\n"); - end - xrf = 64'hC340000000000000; - y = 64'hC0174A36EB1D6E78; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5347939\n"); - end - xrf = 64'h3FFFF0F657588704; - y = 64'h3FE000007FFFFFFF; - zrf = 64'hB8189E65C7979C08; - ans = 64'h3FEFF0F756E039BD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5348553\n"); - end - xrf = 64'hC340000000000000; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5349167\n"); - end - xrf = 64'h4010020000000000; - y = 64'h39E0400000000001; - zrf = 64'hC000000000000000; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5349781\n"); - end - xrf = 64'hC340000000000000; - y = 64'hBFD0000000000000; - zrf = 64'h37E0D12FE384C4E3; - ans = 64'h4320000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5350395\n"); - end - xrf = 64'hB7EFFFFFFDEFFFFF; - y = 64'hB8154F38A295A0D4; - zrf = 64'h0A601000000001FE; - ans = 64'h30154F38A13605AD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5351009\n"); - end - xrf = 64'h4031AC88E06F1232; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h3CA0000000000000; - ans = 64'hC021AC88E06F1231; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5351623\n"); - end - xrf = 64'hC340000000000000; - y = 64'hB7FFFFFFFFF7FF7E; - zrf = 64'h801686808946DCFE; - ans = 64'h3B4FFFFFFFF7FF7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5352237\n"); - end - xrf = 64'hC03E0000000FFFFE; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h40D0001FFFFFFFFD; - ans = 64'h40D003E0000001FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5352851\n"); - end - xrf = 64'hC340000000000000; - y = 64'hBEEDFFFFFFFBFFFF; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5353465\n"); - end - xrf = 64'hC7EFFF7FFFFFFFEF; - y = 64'hB715D828C4ABF26E; - zrf = 64'hC7F3FFFFFFFFFDFE; - ans = 64'hC7F3FFFFFFFFFDFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5354079\n"); - end - xrf = 64'hC340000000000000; - y = 64'hBFE0000000000001; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5354693\n"); - end - xrf = 64'hC01FFFFF7EFFFFFF; - y = 64'h3FD7FFFFFFFFFEFF; - zrf = 64'hBFF0000000000001; - ans = 64'hC00FFFFF9F3FFEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5355307\n"); - end - xrf = 64'hC340000000000000; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hBFE0001FFFFFEFFF; - ans = 64'h433FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5355921\n"); - end - xrf = 64'hC2B0000000020006; - y = 64'h3FFFFEFFFFFF7FFF; - zrf = 64'hC1FFEFFFFFFFBFFE; - ans = 64'hC2C0007F8001BFF3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5356535\n"); - end - xrf = 64'h2DD00000FFFDFFFE; - y = 64'hBFF0000000000001; - zrf = 64'h0010000000000001; - ans = 64'hADD00000FFFDFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5357149\n"); - end - xrf = 64'hC340000000000000; - y = 64'hC1D000005FFFFFFF; - zrf = 64'hFFF00100FFFFFFFE; - ans = 64'hFFF80100FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5357763\n"); - end - xrf = 64'h480FFFFFDDFFFFFF; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'hBFBFFFFFFBFFFF7E; - ans = 64'hC81FFFFFDDFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5358377\n"); - end - xrf = 64'hC340000000000000; - y = 64'h43EFFF0000001FFF; - zrf = 64'h4340000000000001; - ans = 64'hC73FFF0000001FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5358991\n"); - end - xrf = 64'h40330C0E018E848D; - y = 64'h3E8E800000000000; - zrf = 64'h407FFDFFFFFF0000; - ans = 64'h407FFE000488DF56; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5359605\n"); - end - xrf = 64'hC340000000000000; - y = 64'hC000000000000000; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5360219\n"); - end - xrf = 64'h001DFFFFFFFFFFFE; - y = 64'hC1EFFFFFDFFFFFFF; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5360833\n"); - end - xrf = 64'hC340000000000000; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h3FC21F4DF8624763; - ans = 64'h435FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5361447\n"); - end - xrf = 64'h594000000100000F; - y = 64'hBCF001FFFFFFDFFF; - zrf = 64'h3FB000200007FFFE; - ans = 64'hD64002000100000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5362061\n"); - end - xrf = 64'h43EC60504E64CB36; - y = 64'hC010000000000000; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hC40C60504E64CB36; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5362675\n"); - end - xrf = 64'hC340000000000000; - y = 64'h348FFFFE00010000; - zrf = 64'hC3EFFC0000007FFE; - ans = 64'hC3EFFC0000007FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5363289\n"); - end - xrf = 64'h41F007FFFBFFFFFE; - y = 64'hC010000000000001; - zrf = 64'h3FCFFFFFFFFFFC00; - ans = 64'hC21007FFFBFEFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5363903\n"); - end - xrf = 64'hC340000000000000; - y = 64'hC0242ED66B9EF685; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h43742ED66B9EF685; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5364517\n"); - end - xrf = 64'h92B0BEA241537B22; - y = 64'hBFFAEFF0327102EE; - zrf = 64'h3FDFFFFFF83FFFFE; - ans = 64'h3FDFFFFFF83FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5365131\n"); - end - xrf = 64'hC340000000000000; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'h4367FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5365745\n"); - end - xrf = 64'hC1F7FBFFFFFFFFFF; - y = 64'hBFD0001D8258BEEC; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'h41D7FC2C3C048831; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5366359\n"); - end - xrf = 64'hC340000000000000; - y = 64'hC340000000000001; - zrf = 64'hC210B42D32FC4C80; - ans = 64'h4690000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5366973\n"); - end - xrf = 64'hCFDFFFFF80003FFF; - y = 64'h3FC7BBC6D35A26DA; - zrf = 64'h4340000000000801; - ans = 64'hCFB7BBC6746B3B03; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5367587\n"); - end - xrf = 64'hC3D00000FFFF8000; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5368201\n"); - end - xrf = 64'hC340000000000000; - y = 64'hC1CA9F116A7C7799; - zrf = 64'hC3C03EFFFFFFFFFF; - ans = 64'h451A9F10E8847799; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5368815\n"); - end - xrf = 64'h7FE25ABC6C8659B2; - y = 64'hFFE0000000000000; - zrf = 64'h407FFFFFFFFFFF7F; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5369429\n"); - end - xrf = 64'hC340000000000000; - y = 64'hC7FFFFFDBFFFFFFF; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h4B4FFFFDBFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5370043\n"); - end - xrf = 64'hBFDFE000000FFFFE; - y = 64'hC0100FFFFFFFFF7E; - zrf = 64'h3FCF8A0B3383F2C2; - ans = 64'h4001F890B34046AA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5370657\n"); - end - xrf = 64'hC340000000000000; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5371271\n"); - end - xrf = 64'hC3CDFFFFEFFFFFFF; - y = 64'hD949AB1857A60219; - zrf = 64'hBFD0000000000000; - ans = 64'h5D281066C55615CB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5371885\n"); - end - xrf = 64'hC340000000000000; - y = 64'hFFF0000000000000; - zrf = 64'h499FFFFFFFEBFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5372499\n"); - end - xrf = 64'hBCA00003FC000000; - y = 64'h41CCE38354F257B0; - zrf = 64'h001E68078B0271CD; - ans = 64'hBE7CE38A869A4C17; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5373113\n"); - end - xrf = 64'hC02FFFFFFE03FFFE; - y = 64'hFFF0000000000001; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5373727\n"); - end - xrf = 64'hC340000000000000; - y = 64'hBF7000000FFFFFFE; - zrf = 64'h3DFFFFFBFFFF0000; - ans = 64'h42C000000FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5374341\n"); - end - xrf = 64'h40300000003EFFFE; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h0B1FFFF7C0000000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5374955\n"); - end - xrf = 64'hC340000000000001; - y = 64'hC14FFFFDFFFFE000; - zrf = 64'h4000000000000000; - ans = 64'h449FFFFDFFFFE002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5375569\n"); - end - xrf = 64'hC3E7FFFFFFFFFBFE; - y = 64'hB80001000FFFFFFF; - zrf = 64'hC02F0000000001FF; - ans = 64'hC02F0000000001FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5376183\n"); - end - xrf = 64'hC340000000000001; - y = 64'h0000000000000001; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5376797\n"); - end - xrf = 64'hC1DFFF8000FFFFFF; - y = 64'hC00FFFFFFFFBFFFF; - zrf = 64'hBCA0000000000001; - ans = 64'h41FFFF8000FC000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5377411\n"); - end - xrf = 64'hC340000000000001; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hC00FFDFFFF000000; - ans = 64'hC00FFDFFFF000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5378025\n"); - end - xrf = 64'hC02FFFFE000000FE; - y = 64'hC001FFFFFFFFFFEF; - zrf = 64'h3FD000100000FFFF; - ans = 64'h40421FFF0000027E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5378639\n"); - end - xrf = 64'h36C000000001F800; - y = 64'h0010000000000000; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5379253\n"); - end - xrf = 64'hC340000000000001; - y = 64'h3D3C00C81E652D3C; - zrf = 64'h3F714A1A50C86C7F; - ans = 64'hC08C00BF795804DA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5379867\n"); - end - xrf = 64'h41F004000FFFFFFE; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h402D2CF073903F81; - ans = 64'h402D2CF073903F81; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5380481\n"); - end - xrf = 64'hC340000000000001; - y = 64'h3E6000000FFFFFF6; - zrf = 64'h3FF0000000000001; - ans = 64'hC1B000000EFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5381095\n"); - end - xrf = 64'hFFFFBF7FFFFFFFFF; - y = 64'hBFA00FFFF7FFFFFF; - zrf = 64'hC05FFFFE80000000; - ans = 64'hFFFFBF7FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5381709\n"); - end - xrf = 64'hC340000000000001; - y = 64'h3CA0000000000000; - zrf = 64'hC000000000000001; - ans = 64'hC008000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5382323\n"); - end - xrf = 64'hBCA8DFE917EDB098; - y = 64'hC0DC000000000200; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h3D95C3EBF4EFFC13; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5382937\n"); - end - xrf = 64'hC340000000000001; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hBFE113EA5470FF5C; - ans = 64'hC00444FA951C3FD7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5383551\n"); - end - xrf = 64'h3FD51CC3620F4006; - y = 64'hBFE000000003FBFF; - zrf = 64'hC130800000000000; - ans = 64'hC13080002A3986C4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5384165\n"); - end - xrf = 64'h3DDFFFFF8000000E; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5384779\n"); - end - xrf = 64'hC340000000000001; - y = 64'hBFF0000002001FFF; - zrf = 64'h3FDDFFFFFFBFFFFF; - ans = 64'h4340000002002000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5385393\n"); - end - xrf = 64'hBF7000000000003F; - y = 64'h3FD0000000000001; - zrf = 64'h3750000000001DFF; - ans = 64'hBF50000000000040; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5386007\n"); - end - xrf = 64'hC340000000000001; - y = 64'hECEFEFFFFFFDFFFF; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h703FEFFFFFFE0001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5386621\n"); - end - xrf = 64'h3F5FFF5FFFFFFFFE; - y = 64'h48FFFFFE01FFFFFF; - zrf = 64'hC6446C7F938A3E6F; - ans = 64'h486FFF5E0204DADD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5387235\n"); - end - xrf = 64'hC340000000000001; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hC330000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5387849\n"); - end - xrf = 64'hFFFFFFF880000000; - y = 64'h7FFFFFEFFFFFFFFD; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hFFFFFFF880000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5388463\n"); - end - xrf = 64'hC340000000000001; - y = 64'h3FE0000000000001; - zrf = 64'hC7E0000FFFEFFFFE; - ans = 64'hC7E0000FFFEFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5389077\n"); - end - xrf = 64'hA7EE490B0364AC37; - y = 64'hC7E0000037FFFFFF; - zrf = 64'h41DF7FFFFFFEFFFF; - ans = 64'h41DF7FFFFFFEFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5389691\n"); - end - xrf = 64'hC00FFFFFFFFFFFE0; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC027FFFFFFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5390305\n"); - end - xrf = 64'hC340000000000001; - y = 64'hFFE200000007FFFF; - zrf = 64'h36B3457E30C0E28E; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5390919\n"); - end - xrf = 64'h43EA5F475FE5AD28; - y = 64'h3FF0000000000000; - zrf = 64'h41C0100800000000; - ans = 64'h43EA5F475FE9B12A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5391533\n"); - end - xrf = 64'hC340000000000001; - y = 64'hC1D000003FFBFFFF; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h452000003FFC0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5392147\n"); - end - xrf = 64'hBCA03FFFFFFFF800; - y = 64'h3A9000000080FFFF; - zrf = 64'hC00CA14FB3B0E309; - ans = 64'hC00CA14FB3B0E309; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5392761\n"); - end - xrf = 64'hC340000000000001; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hC350000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5393375\n"); - end - xrf = 64'h3AEFFFF000200000; - y = 64'hBFD89BBFE7461D34; - zrf = 64'h8000000000000000; - ans = 64'hBAD89BB3997EC551; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5393989\n"); - end - xrf = 64'hC340000000000001; - y = 64'h4000000000000000; - zrf = 64'h417000000041FFFF; - ans = 64'hC34FFFFFFF800002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5394603\n"); - end - xrf = 64'hBE428CEEAE12FD06; - y = 64'h001FF7FFEFFFFFFF; - zrf = 64'h9A1EEB349155F780; - ans = 64'h9A1EEB349155F780; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5395217\n"); - end - xrf = 64'hFFD24D26EE83909E; - y = 64'h4000000000000001; - zrf = 64'hC010000000000000; - ans = 64'hFFE24D26EE83909F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5395831\n"); - end - xrf = 64'hC340000000000001; - y = 64'h5A2A5C7FC406F5A4; - zrf = 64'h41E1BF2787EC1D5C; - ans = 64'hDD7A5C7FC406F5A6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5396445\n"); - end - xrf = 64'h329FFFFFFFFFFE7F; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hC1CFFDFFFFFFFFFB; - ans = 64'hC1CFFDFFFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5397059\n"); - end - xrf = 64'hC340000000000001; - y = 64'h3FDFFFFFFF003FFF; - zrf = 64'h3FD0000000000000; - ans = 64'hC32FFFFFFF004000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5397673\n"); - end - xrf = 64'h400000007DFFFFFF; - y = 64'h726B20DC29B76BDB; - zrf = 64'h74FFE000001FFFFF; - ans = 64'h74FFE00000201B20; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5398287\n"); - end - xrf = 64'hC340000000000001; - y = 64'h4010000000000001; - zrf = 64'hBFE0000000000000; - ans = 64'hC360000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5398901\n"); - end - xrf = 64'h45AFFFBFFFFFE000; - y = 64'h420FFFFBFDFFFFFF; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5399515\n"); - end - xrf = 64'hC340000000000001; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hC09FFFFBFFFFFFEF; - ans = 64'hC370000000000080; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5400129\n"); - end - xrf = 64'h3FEFFFFFFFFF7FE0; - y = 64'hC3BF9FFFFFFFFFFF; - zrf = 64'h43000000040000FF; - ans = 64'hC3BF9DFFFFFF015F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5400743\n"); - end - xrf = 64'h137FFFFFFFFFFFF1; - y = 64'h4340000000000000; - zrf = 64'hC000000000000001; - ans = 64'hC000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5401357\n"); - end - xrf = 64'hC340000000000001; - y = 64'h3FDFFFFFF0000000; - zrf = 64'hC1D00007FFFDFFFF; - ans = 64'hC330000038002001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5401971\n"); - end - xrf = 64'hB7F52576162C1295; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'hC0BFFE07FFFFFFFE; - ans = 64'hC0BFFE07FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5402585\n"); - end - xrf = 64'hC340000000000001; - y = 64'hBFDFFEFFFFFFFFFD; - zrf = 64'h3CA0000000000001; - ans = 64'h432FFEFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5403199\n"); - end - xrf = 64'hC040000000008800; - y = 64'h40300000027FFFFF; - zrf = 64'h9E2AA3D24C9A711B; - ans = 64'hC0800000028087FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5403813\n"); - end - xrf = 64'hC340000000000001; - y = 64'h7FE0000000000000; - zrf = 64'hBFD0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5404427\n"); - end - xrf = 64'hFBFF8000000FFFFF; - y = 64'hBFD41AC82DBBB86E; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5405041\n"); - end - xrf = 64'hC340000000000001; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hC1EC00000007FFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5405655\n"); - end - xrf = 64'h47E000000007FEFF; - y = 64'h3FF0040000FFFFFF; - zrf = 64'h3FC001FFFDFFFFFF; - ans = 64'h47E00400010800FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5406269\n"); - end - xrf = 64'h31700000000FDFFF; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'h71700000000FDFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5406883\n"); - end - xrf = 64'hC340000000000001; - y = 64'hC0EFFFFFFFFFFFE7; - zrf = 64'h41CA72A02562B0DD; - ans = 64'h4440000000001A67; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5407497\n"); - end - xrf = 64'hC03FFFFFFFFFBDFE; - y = 64'h7FF0000000000001; - zrf = 64'h7FDFFC00000007FE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5408111\n"); - end - xrf = 64'hC340000000000001; - y = 64'h3FFD9DA214DE7CE2; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'hC34D9DA214DE7CE4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5408725\n"); - end - xrf = 64'hF8E080003FFFFFFE; - y = 64'hBC1D4FC87697AFF3; - zrf = 64'h344FFFC040000000; - ans = 64'h750E3A472F8B8F49; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5409339\n"); - end - xrf = 64'hC340000000000001; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5409953\n"); - end - xrf = 64'hC3D19B02AC11A154; - y = 64'hB72FFFE7FFFFFFFE; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h434FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5410567\n"); - end - xrf = 64'hC340000000000001; - y = 64'h8000000000000001; - zrf = 64'hBE98EC582E43D1DC; - ans = 64'hBE98EC582E43D1DC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5411181\n"); - end - xrf = 64'h403F8F3651092926; - y = 64'hC03FFF007FFFFFFE; - zrf = 64'hC1EFFFFFFFF9FFFF; - ans = 64'hC1F000003F1974AB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5411795\n"); - end - xrf = 64'h43D008001FFFFFFF; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hBFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5412409\n"); - end - xrf = 64'hC340000000000001; - y = 64'h3FB087E591490CAC; - zrf = 64'h3C1FFFFFFFFFFEFA; - ans = 64'hC30087E591490CAD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5413023\n"); - end - xrf = 64'hC02DFFFFFFFFF7FE; - y = 64'h8010000000000000; - zrf = 64'hCCE08000003FFFFE; - ans = 64'hCCE08000003FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5413637\n"); - end - xrf = 64'hC340000000000001; - y = 64'h19648D4F49384B9E; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h9CB48D4F49384B9F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5414251\n"); - end - xrf = 64'hF550000080000FFF; - y = 64'hC0236D4E1B9C8B6B; - zrf = 64'hFFE0080000010000; - ans = 64'hFFE0080000010000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5414865\n"); - end - xrf = 64'hC340000000000001; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h0370000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5415479\n"); - end - xrf = 64'h8C2FFFFFFFF1FFFF; - y = 64'hC0262AAAD6746AFA; - zrf = 64'h4340000000000000; - ans = 64'h4340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5416093\n"); - end - xrf = 64'hC340000000000001; - y = 64'hBCA0000000000000; - zrf = 64'hC3C0000007FFFFFD; - ans = 64'hC3C0000007FFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5416707\n"); - end - xrf = 64'h47F6D5F276B32FF2; - y = 64'h31CC3FE8B24739C3; - zrf = 64'h37E0010000000080; - ans = 64'h39D428CF6BAD41EC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5417321\n"); - end - xrf = 64'hB81FFFFFFFC001FF; - y = 64'hBCA0000000000001; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5417935\n"); - end - xrf = 64'hC340000000000001; - y = 64'h3E7FFFFFBFBFFFFF; - zrf = 64'hB7E00000000002FF; - ans = 64'hC1CFFFFFBFC00001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5418549\n"); - end - xrf = 64'hBFDCE4CBF7D10BF3; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h00208003FFFFFFFF; - ans = 64'h3C9CE4CBF7D10BF1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5419163\n"); - end - xrf = 64'hC340000000000001; - y = 64'hBE5FFFFFFF007FFF; - zrf = 64'h0000000000000000; - ans = 64'h41AFFFFFFF008001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5419777\n"); - end - xrf = 64'hDE000000800003FE; - y = 64'h41E3CEE8DDE145F1; - zrf = 64'hBFD0000000003FFE; - ans = 64'hDFF3CEE97C5891D1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5420391\n"); - end - xrf = 64'hC340000000000001; - y = 64'hBFD0000000000001; - zrf = 64'h8010000000000000; - ans = 64'h4320000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5421005\n"); - end - xrf = 64'h401FFFFFEF800000; - y = 64'hBFBFFFFFFE00007E; - zrf = 64'h4010000000000001; - ans = 64'h40080000049FFFE2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5421619\n"); - end - xrf = 64'hC340000000000001; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'hBFFFFFFF80000040; - ans = 64'h432FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5422233\n"); - end - xrf = 64'hC7F01FFEFFFFFFFF; - y = 64'hBFB5FF38A7479155; - zrf = 64'hC3D00000080FFFFF; - ans = 64'h47B62B35B8A29602; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5422847\n"); - end - xrf = 64'hD911B7AC0CBADB59; - y = 64'hBFE0000000000000; - zrf = 64'hBFD0000000000001; - ans = 64'h5901B7AC0CBADB59; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5423461\n"); - end - xrf = 64'hC340000000000001; - y = 64'hC09000009FFFFFFF; - zrf = 64'hBF2B93ADF5352966; - ans = 64'h43E00000A0000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5424075\n"); - end - xrf = 64'hC3E003FFFFFFFFDF; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hC340000021000000; - ans = 64'h43DFFFFFFFEF7FBD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5424689\n"); - end - xrf = 64'hC340000000000001; - y = 64'hBE0FFDFFFFFFFFFB; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5425303\n"); - end - xrf = 64'h41C4000000000001; - y = 64'hC3CFF8000001FFFF; - zrf = 64'h5DAFFFFFFFFFF020; - ans = 64'h5DAFFFFFFFFFF020; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5425917\n"); - end - xrf = 64'hC340000000000001; - y = 64'hBFF0000000000000; - zrf = 64'h8000000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5426531\n"); - end - xrf = 64'hC49020000000003E; - y = 64'h37E70E224EAA7694; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h400FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5427145\n"); - end - xrf = 64'hC340000000000001; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'hBFF4BC1B8E9A288F; - ans = 64'h4350000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5427759\n"); - end - xrf = 64'h40E0008000000080; - y = 64'hC7F0A5389308A4FD; - zrf = 64'h3FE0000000080020; - ans = 64'hC8E0A5BDBCCD3DC7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5428373\n"); - end - xrf = 64'hB890008000000003; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5428987\n"); - end - xrf = 64'hC340000000000001; - y = 64'hC2FFFFFF000FFFFF; - zrf = 64'h3FFFFFFFC00003FF; - ans = 64'h464FFFFF00100001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5429601\n"); - end - xrf = 64'hC1DFFFFC000007FE; - y = 64'hC000000000000001; - zrf = 64'hC190000000010001; - ans = 64'h41EF7FFC00000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5430215\n"); - end - xrf = 64'hC340000000000001; - y = 64'h40100020000000FE; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5430829\n"); - end - xrf = 64'h41EFDFFFFFE00000; - y = 64'h3FFFF7FFFEFFFFFE; - zrf = 64'hBC1F4C2FEB97528D; - ans = 64'h41FFD807FEE107FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5431443\n"); - end - xrf = 64'hC340000000000001; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5432057\n"); - end - xrf = 64'hA448A5F97BD5F2C3; - y = 64'h41DFFFFFFFFBFFFF; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h3FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5432671\n"); - end - xrf = 64'hC340000000000001; - y = 64'hC010000000000001; - zrf = 64'h417FFFFFFFFFF010; - ans = 64'h4360000000400002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5433285\n"); - end - xrf = 64'h60B6EE937AC4CF69; - y = 64'hC3DA08AD28FFC588; - zrf = 64'h3FFFFFFFFBFFBFFE; - ans = 64'hE4A2A80F8FCD6C80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5433899\n"); - end - xrf = 64'hBCA0000008000200; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h3CD00000080001FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5434513\n"); - end - xrf = 64'hC340000000000001; - y = 64'h4010018000000000; - zrf = 64'hFFEFFFFFFEEFFFFF; - ans = 64'hFFEFFFFFFEEFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5435127\n"); - end - xrf = 64'h001FFFEFFFFFFFFF; - y = 64'hC340000000000000; - zrf = 64'hCF8DC493D93984C7; - ans = 64'hCF8DC493D93984C7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5435741\n"); - end - xrf = 64'hC340000000000001; - y = 64'hC04000FFFFFEFFFF; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'h438E01FFFFFE0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5436355\n"); - end - xrf = 64'h40100000007BFFFE; - y = 64'h450000000000011F; - zrf = 64'hC08007FFFF7FFFFF; - ans = 64'h45200000007C011D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5436969\n"); - end - xrf = 64'hC340000000000001; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5437583\n"); - end - xrf = 64'hC014200000000000; - y = 64'hC03FFFFBFDFFFFFE; - zrf = 64'h3FF0000000000000; - ans = 64'h40643FFD7ABDFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5438197\n"); - end - xrf = 64'hC340000000000001; - y = 64'hFFE0000000000000; - zrf = 64'h37FA8D65839D9274; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5438811\n"); - end - xrf = 64'hC51FFFFFC0008000; - y = 64'hBFD001FFFFFFFFFB; - zrf = 64'h406FFFFFBC000000; - ans = 64'h450001FFDFFC4003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5439425\n"); - end - xrf = 64'hBFA0000000000043; - y = 64'hFFE0000000000001; - zrf = 64'h8010000000000000; - ans = 64'h7F90000000000044; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5440039\n"); - end - xrf = 64'hC340000000000001; - y = 64'hC1D5D0BE91430DC6; - zrf = 64'h43FFFFFFFFF8007E; - ans = 64'h4525D0C291430DC6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5440653\n"); - end - xrf = 64'hC3FFDFFFBFFFFFFE; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'hB0AFFFF880000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5441267\n"); - end - xrf = 64'hC340000000000001; - y = 64'h3390000007FDFFFE; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5441881\n"); - end - xrf = 64'h45DFFE4000000000; - y = 64'h8000000010000000; - zrf = 64'hBFBE00000000001F; - ans = 64'hBFBE00000000001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5442495\n"); - end - xrf = 64'hC340000000000001; - y = 64'hFFF0000000000001; - zrf = 64'h7FE0000000000000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5443109\n"); - end - xrf = 64'h4000FFFFFFFF7FFF; - y = 64'h3C4FFFE000004000; - zrf = 64'h3FE0000000000001; - ans = 64'h3FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5443723\n"); - end - xrf = 64'hC340000000000001; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h3F90000077FFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5444337\n"); - end - xrf = 64'h52700001FFFFFE00; - y = 64'h3FCFFFFF800FFFFE; - zrf = 64'h3F15FFFFFFFFFFFF; - ans = 64'h52500001C007F600; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5444951\n"); - end - xrf = 64'hBFD00000FFFBFFFF; - y = 64'h0000000000000000; - zrf = 64'h8000000000000001; - ans = 64'h8000000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5445565\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hBFA4000000000000; - zrf = 64'h802FFFF7FFFFEFFF; - ans = 64'h4303FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5446179\n"); - end - xrf = 64'h371AB38F765B1DEC; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h8003FFFFFEFFFFFE; - ans = 64'h8003FFFFFEFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5446793\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hC42003FFFFF7FFFF; - zrf = 64'hC010000000000001; - ans = 64'h478003FFFFF7FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5447407\n"); - end - xrf = 64'h3CFDD7FE244AFBC9; - y = 64'hBE9FF7FFFFFFFFEE; - zrf = 64'h47EFFFFFFFFFEFFF; - ans = 64'h47EFFFFFFFFFEFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5448021\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h0010000000000000; - zrf = 64'h4340000000000001; - ans = 64'h4340000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5448635\n"); - end - xrf = 64'h43D000000FFFFF7F; - y = 64'h400E000007FFFFFF; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h43EE000025FFFF15; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5449249\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h0010000000000001; - zrf = 64'h400A4ACF9C6ECFCF; - ans = 64'h400A4ACF9C6ECFCF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5449863\n"); - end - xrf = 64'hC3A000000FFFFF7F; - y = 64'h80000000000005FE; - zrf = 64'h001000003FFFFBFF; - ans = 64'h0127F80817F81F3F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5450477\n"); - end - xrf = 64'h3DB0000000FFFFFF; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5451091\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hB7E00000000003F6; - zrf = 64'h43EFFFFFFFFFF83F; - ans = 64'h43EFFFFFFFFFF83F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5451705\n"); - end - xrf = 64'hBD60000004040000; - y = 64'h3CA0000000000001; - zrf = 64'hBCFEF80000000000; - ans = 64'hBCFEF80000000040; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5452319\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h3E4A64516D53FAB4; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC1AA64517553FAB3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5452933\n"); - end - xrf = 64'h3FE000200007FFFF; - y = 64'hC110FFFFFFFBFFFF; - zrf = 64'hC1C8CE2B1BD9B7F8; - ans = 64'hC1C8CF3B1DF9B840; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5453547\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h4010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5454161\n"); - end - xrf = 64'h40DFFFF803FFFFFF; - y = 64'h3FC1FFDFFFFFFFFE; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h40B1FFDB8247FBFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5454775\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h3FD0000000000000; - zrf = 64'hC02FFBFF80000000; - ans = 64'hC33000000000000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5455389\n"); - end - xrf = 64'hC80DAD4F65AAD27C; - y = 64'hC020000008000FFF; - zrf = 64'h8492906128E14AFB; - ans = 64'h483DAD4F748197DA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5456003\n"); - end - xrf = 64'h40DCF3C559C034F5; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5456617\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hC035E5D29C974662; - zrf = 64'h3E0FFE000003FFFE; - ans = 64'h4395E5D29C974661; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5457231\n"); - end - xrf = 64'h380FFFFFFFFFFDF7; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'hB8C0007FFFFFFFFD; - ans = 64'hB8BFFEFFFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5457845\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h3FE00000107FFFFF; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hC3400000107FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5458459\n"); - end - xrf = 64'h3E1BC6643D55F65C; - y = 64'h419FFFF000FFFFFE; - zrf = 64'hC002C8A53A95E171; - ans = 64'hC0010C3FD4E5C0C4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5459073\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5459687\n"); - end - xrf = 64'hC01809D31DFFF55A; - y = 64'h3FD5BC62545A25C1; - zrf = 64'h3CA0000000000000; - ans = 64'hC00053F6217446D1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5460301\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'hC3E2004000000000; - ans = 64'hC3E2084000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5460915\n"); - end - xrf = 64'hC7F00001FF800000; - y = 64'hC3CFF0001FFFFFFF; - zrf = 64'hB19007FFFFDFFFFF; - ans = 64'h4BCFF0041D0083FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5461529\n"); - end - xrf = 64'hB7E007FFFFFFFFBF; - y = 64'h3FF0000000000001; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5462143\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hBF243D40C83AC199; - zrf = 64'h002FBFFFF8000000; - ans = 64'h42843D40C83AC198; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5462757\n"); - end - xrf = 64'hC2818DED3593E52A; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h480FFFF00003FFFF; - ans = 64'h480FFFF00003FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5463371\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hBF2BA99F892603E6; - zrf = 64'hBFF0000000000000; - ans = 64'h428BA99F8925FBE5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5463985\n"); - end - xrf = 64'h412EAAA12F11A7DB; - y = 64'hC80C00000000003E; - zrf = 64'hB80C0000000007FF; - ans = 64'hC94AD54D092F731B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5464599\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h4000000000000001; - zrf = 64'h4000000000000000; - ans = 64'hC360000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5465213\n"); - end - xrf = 64'h39717FFFFFFFFFFE; - y = 64'hC3E0000000010002; - zrf = 64'h0010000000000001; - ans = 64'hBD61800000011800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5465827\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h40300010001FFFFF; - ans = 64'hC36FFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5466441\n"); - end - xrf = 64'hB80FFFE00007FFFF; - y = 64'hBF9FFFFFFFFEFFDF; - zrf = 64'h4B9FFFFFFFFC0002; - ans = 64'h4B9FFFFFFFFC0002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5467055\n"); - end - xrf = 64'h49BEC177C9ED4F15; - y = 64'h4010000000000000; - zrf = 64'h4340000000000001; - ans = 64'h49DEC177C9ED4F15; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5467669\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h43E0010000000400; - zrf = 64'h3FDDFFFFFFBFFFFE; - ans = 64'hC7400100000003FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5468283\n"); - end - xrf = 64'h4020001FFFEFFFFE; - y = 64'h4010000000000001; - zrf = 64'h407FEFFFDFFFFFFE; - ans = 64'h4080F801EFFEFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5468897\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h41F00001FFFFFFF7; - zrf = 64'hBFE0000000000001; - ans = 64'hC5500001FFFFFFF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5469511\n"); - end - xrf = 64'h33F000007DFFFFFE; - y = 64'h002928B16DF7CBB4; - zrf = 64'hBCAFFEFFFFBFFFFF; - ans = 64'hBCAFFEFFFFBFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5470125\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h4340000000000000; - zrf = 64'h3FF0000000000001; - ans = 64'hC69FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5470739\n"); - end - xrf = 64'h406FFFFF800001FF; - y = 64'h40F077FFFFFFFFFE; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h417077FFBE200105; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5471353\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h4340000000000001; - zrf = 64'hC06000000003FFBE; - ans = 64'hC6A0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5471967\n"); - end - xrf = 64'hB7FA7CEC0D9A63FC; - y = 64'hBFBFFFFFFFFFE0FE; - zrf = 64'hC3D0000000000600; - ans = 64'hC3D0000000000600; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5472581\n"); - end - xrf = 64'h433FFFFFFFFEFFDF; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h469FFFFFFFFEFFDD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5473195\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hC87637A768F4FEFA; - zrf = 64'h3FFFFC000007FFFF; - ans = 64'h4BD637A768F4FEF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5473809\n"); - end - xrf = 64'hD68000000007FE00; - y = 64'h7FE0000000000000; - zrf = 64'h403FFFFFFFFFB7FF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5474423\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hF024C37474C9D33C; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'h7384C37474C9D33B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5475037\n"); - end - xrf = 64'h2CD000200003FFFF; - y = 64'h51D0000001000008; - zrf = 64'hC07FFFFFFFFFFFEB; - ans = 64'hC07FFFFFFEFFFDEB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5475651\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5476265\n"); - end - xrf = 64'hB3740003FFFFFFFE; - y = 64'hBFBFFFAFFFFFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5476879\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h7FF0000000000000; - zrf = 64'hC03AE6BE1F9E24E8; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5477493\n"); - end - xrf = 64'hBFB07FFFF8000000; - y = 64'hC17F7FFFFFFFFF00; - zrf = 64'hBCBFFF6000000000; - ans = 64'h41403DFFF81FFF7C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5478107\n"); - end - xrf = 64'hB7F003FFEFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5478721\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h43DFFFFFFFFFEFBE; - zrf = 64'h43EFFFFFFFFFFE20; - ans = 64'hC73FFFFFFFFFEFBC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5479335\n"); - end - xrf = 64'h47FC0001FFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'hC3DEB1712362F9CA; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5479949\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h480FFFFFDFFFFFFA; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hCB6FFFFFDFFFFFF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5480563\n"); - end - xrf = 64'hC0200000000FC000; - y = 64'hB7F000400000007F; - zrf = 64'hBFDFFFFFBFFFFFFE; - ans = 64'hBFDFFFFFBFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5481177\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5481791\n"); - end - xrf = 64'h7FF00000407FFFFF; - y = 64'hC00BFFFFFFFBFFFF; - zrf = 64'hFFF0000000000000; - ans = 64'h7FF80000407FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5482405\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h2270200000001000; - ans = 64'h2270200000001000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5483019\n"); - end - xrf = 64'h43CBFAD00FE40BD0; - y = 64'h9E80000000FFF800; - zrf = 64'h4000000000003FF6; - ans = 64'h4000000000003FF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5483633\n"); - end - xrf = 64'hC03F273CB9257F43; - y = 64'h8010000000000001; - zrf = 64'h4000000000000000; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5484247\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hC3C92743C95CDEC2; - zrf = 64'h38054C86136783E3; - ans = 64'h47292743C95CDEC1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5484861\n"); - end - xrf = 64'h7FF0001080000000; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h3DCFFFFFFFFFDFFE; - ans = 64'h7FF8001080000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5485475\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h7FF0000100080000; - zrf = 64'hBCA0000000000000; - ans = 64'h7FF8000100080000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5486089\n"); - end - xrf = 64'hB81FEFFFF7FFFFFF; - y = 64'h41CF7DFFFFFFFFFE; - zrf = 64'h297DD0ABC1CC695B; - ans = 64'hB9FF6E40F8207FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5486703\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hBCA0000000000001; - zrf = 64'h3FD0000000000000; - ans = 64'h4002000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5487317\n"); - end - xrf = 64'hC7F000007FFFFF7F; - y = 64'h3FBB7B8C5D12A5A8; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5487931\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h405000200000FFFF; - ans = 64'h405100200000FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5488545\n"); - end - xrf = 64'hC02000001FFFFFDE; - y = 64'h47F000000000401F; - zrf = 64'h41D17EC67F9FA694; - ans = 64'hC820000020003FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5489159\n"); - end - xrf = 64'h37FFFFC00001FFFF; - y = 64'hBFD0000000000000; - zrf = 64'h3FF0000000000001; + z = 64'h3FF0000000000001; ans = 64'h3FF0000000000001; rn = 1; rz = 0; @@ -420238,19 +116475,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -420266,12 +116503,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5489773\n"); + $fwrite(fp,"4990691\n"); end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hC5D000007FFFFFFF; - zrf = 64'hA1FFFFFFFFFFFDEF; - ans = 64'h493000007FFFFFFE; + x = 64'h7FEFFFFFFC004000; + y = 64'hBCA0000000000000; + z = 64'h409C00001FFFFFFF; + ans = 64'hFC9FFFFFFC004000; rn = 1; rz = 0; rm = 0; @@ -420285,19 +116522,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -420313,12 +116550,59 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5490387\n"); + $fwrite(fp,"4992705\n"); end - xrf = 64'hC03FFFFFFF7F8000; + x = 64'hBFC003FFFFFFF000; + y = 64'h982FFFFFFF7EFFFF; + z = 64'hC7EFFFFFBFFFDFFF; + ans = 64'hC7EFFFFFBFFFDFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"4994719\n"); + end + x = 64'hC00FFFFFFFFFFFFE; y = 64'hBFD0000000000001; - zrf = 64'hBFFFFFFDFFC00000; - ans = 64'h401800007F8F8002; + z = 64'hC340000000000000; + ans = 64'hC33FFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -420332,19 +116616,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -420360,106 +116644,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5491001\n"); + $fwrite(fp,"4996733\n"); end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hBFB000000FFFFFFB; - zrf = 64'h8010000000000001; - ans = 64'h431000000FFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5491615\n"); - end - xrf = 64'h41DFF77FFFFFFFFF; - y = 64'h402151FEE5037E15; - zrf = 64'h403FFFFFFFFFFFF0; - ans = 64'h42114D651DCEA927; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5492229\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; + x = 64'hC02072F3B0873040; y = 64'hBFE0000000000000; - zrf = 64'h3CA0000000000001; - ans = 64'h433FFFFFFFFFFFFF; + z = 64'h2178FF86D6E78F62; + ans = 64'h401072F3B0873040; rn = 1; rz = 0; rm = 0; @@ -420473,19 +116663,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -420501,12 +116691,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5492843\n"); + $fwrite(fp,"4998747\n"); end - xrf = 64'h3FE613AEBED509A5; - y = 64'h800FFFFF84000000; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFF; + x = 64'h7FF0000001FFFFFB; + y = 64'hC3D0000000080400; + z = 64'hBFD0000000001F7E; + ans = 64'h7FF8000001FFFFFB; rn = 1; rz = 0; rm = 0; @@ -420520,19 +116710,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -420548,669 +116738,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5493457\n"); + $fwrite(fp,"5000761\n"); end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hBFE0000000000001; - zrf = 64'hC06FFFFDF8000000; - ans = 64'h433FFFFFFFFFFF01; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5494071\n"); - end - xrf = 64'hB8040003FFFFFFFF; - y = 64'h4050000040003FFF; - zrf = 64'h9580000002200000; - ans = 64'hB864000450005FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5494685\n"); - end - xrf = 64'h49CD2F4076804EB9; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'hC9CD2F4076804EB7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5495299\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h30000B80D80C55F7; - zrf = 64'h402FFFF007FFFFFF; - ans = 64'h402FFFF007FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5495913\n"); - end - xrf = 64'hC7E000007FFFFFEF; - y = 64'hBFF0000000000000; - zrf = 64'h4E30041FFFFFFFFF; - ans = 64'h4E30041FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5496527\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hC02F0000000000FF; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h438F0000000000FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5497141\n"); - end - xrf = 64'hC04FFFFA00000000; - y = 64'h480FFFFFFF7F7FFF; - zrf = 64'hBF2000021FFFFFFF; - ans = 64'hC86FFFF9FF7F8017; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5497755\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h435FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5498369\n"); - end - xrf = 64'hBFB0005FFFFFFFFF; - y = 64'h42DFF20000000000; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC29FF2BFAC001FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5498983\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hC000000000000000; - zrf = 64'hB7FFFFFC00007FFF; - ans = 64'h435FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5499597\n"); - end - xrf = 64'h43DC000000002000; - y = 64'h402BFFFBFFFFFFFF; - zrf = 64'h42D0001000FFFFFF; - ans = 64'h44187FFD80011C0F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5500211\n"); - end - xrf = 64'h3D7ADB0575E773A1; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FDFFFFFFFFE524E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5500825\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hC3D0000000000038; - zrf = 64'hC349AD32818DAD1D; - ans = 64'h4730000000000037; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5501439\n"); - end - xrf = 64'hC21F0000000007FF; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h41C84086CAABB3E9; - ans = 64'h423F30810D955F65; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5502053\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h439F80001FFFFFFF; - zrf = 64'h7FFFFFFFFFFFFFFE; + x = 64'hC00FFFFFFFFFFFFE; + y = 64'hBFF0000000000001; + z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -421225,19 +116757,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -421253,12 +116785,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5502667\n"); + $fwrite(fp,"5002775\n"); end - xrf = 64'hBF800017FFFFFFFF; - y = 64'hC090000000202000; - zrf = 64'h3FCFFFFFFFE03FFF; - ans = 64'h40208018001FA12F; + x = 64'h4181A83E99639AD7; + y = 64'hC000000000000000; + z = 64'h3CB4B4507335CAB2; + ans = 64'hC191A83E99639AD7; rn = 1; rz = 0; rm = 0; @@ -421272,19 +116804,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -421300,12 +116832,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5503281\n"); + $fwrite(fp,"5004789\n"); end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h437FFFFFFFFFFFFE; + x = 64'h27C1ED6D778B4BD4; + y = 64'hBA8869EBDC7AAE3D; + z = 64'hBFDFFFFFDFFFFFDE; + ans = 64'hBFDFFFFFDFFFFFDE; rn = 1; rz = 0; rm = 0; @@ -421319,19 +116851,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -421347,12 +116879,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5503895\n"); + $fwrite(fp,"5006803\n"); end - xrf = 64'hBCA00000003FFFFE; - y = 64'h40EFEFFFFFEFFFFE; - zrf = 64'hC010000000000000; - ans = 64'hC010000000001FF0; + x = 64'hC00FFFFFFFFFFFFE; + y = 64'hC010000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h4030000000000000; rn = 1; rz = 0; rm = 0; @@ -421366,19 +116898,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -421394,12 +116926,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5504509\n"); + $fwrite(fp,"5008817\n"); end - xrf = 64'hC34FFFFFFFFFFFFF; + x = 64'hBCCE2E656DD76AF6; y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'hB96F79F2A1CF2EA1; - ans = 64'h437FFFFFFFFFFFFD; + z = 64'h40582EA8FFAB0667; + ans = 64'h40582EA8FFAB0667; rn = 1; rz = 0; rm = 0; @@ -421413,19 +116945,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -421441,12 +116973,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5505123\n"); + $fwrite(fp,"5010831\n"); end - xrf = 64'h403BFFFFFFFFFFFE; - y = 64'h7FF0000200001FFE; - zrf = 64'h33D0FE39A8BBAB11; - ans = 64'h7FF8000200001FFE; + x = 64'hC3E43CF321BA68FA; + y = 64'h9D34000001000000; + z = 64'hC005BF51A5846459; + ans = 64'hC005BF51A5846459; rn = 1; rz = 0; rm = 0; @@ -421460,19 +116992,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -421488,152 +117020,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5505737\n"); + $fwrite(fp,"5012845\n"); end - xrf = 64'hBB5FFBFFDFFFFFFF; - y = 64'hC340000000000001; - zrf = 64'h3FD0000000000000; - ans = 64'h3FD00003FF7FFC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5506351\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hBF90200001FFFFFE; - zrf = 64'hB80ED0F69F81A3D1; - ans = 64'h42F0200001FFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5506965\n"); - end - xrf = 64'h41FFFC00007FFFFF; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hBF9F724AF4D4D384; - ans = 64'hC55FFC00007FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5507579\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hC03000000000FFEF; - zrf = 64'h7FF0000000000000; + x = 64'hC00FFFFFFFFFFFFE; + y = 64'hFFE0000000000000; + z = 64'hBFF0000000000001; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -421648,19 +117039,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -421676,12 +117067,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5508193\n"); + $fwrite(fp,"5014859\n"); end - xrf = 64'hD12FFFFFF0000003; - y = 64'h3EB8E5F86F590FE9; - zrf = 64'h3FB0800003FFFFFF; - ans = 64'hCFF8E5F862E613B4; + x = 64'h00000004000007FE; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hC030000003FFFEFF; + ans = 64'hC0300001040000FE; rn = 1; rz = 0; rm = 0; @@ -421695,19 +117086,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -421723,12 +117114,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5508807\n"); + $fwrite(fp,"5016873\n"); end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hFFE0000000000001; - zrf = 64'h0000000000000000; - ans = 64'h7FF0000000000000; + x = 64'h40000010007FFFFE; + y = 64'h3F6B3DB4BB3D6728; + z = 64'h3FD095716EC3B12B; + ans = 64'h3FD10268AEAAE16B; rn = 1; rz = 0; rm = 0; @@ -421742,19 +117133,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -421770,12 +117161,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5509421\n"); + $fwrite(fp,"5018887\n"); end - xrf = 64'hC5CFFFFFFFC003FE; - y = 64'hC031FFFFFFFFFFFE; - zrf = 64'hC000000000000001; - ans = 64'h4611FFFFFFDC023D; + x = 64'hC010000000000000; + y = 64'h0000000000000000; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; rn = 1; rz = 0; rm = 0; @@ -421789,19 +117180,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -421817,12 +117208,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5510035\n"); + $fwrite(fp,"5020901\n"); end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hC8E0040007FFFFFF; - ans = 64'h7FF0000000000000; + x = 64'h41EFFF80000007FF; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hC00400007FFFFFFF; + ans = 64'hC00400007FFFFFFF; rn = 1; rz = 0; rm = 0; @@ -421836,19 +117227,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -421864,12 +117255,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5510649\n"); + $fwrite(fp,"5022915\n"); end - xrf = 64'hBFCFA1A483AF298E; - y = 64'h0009A2ABE56EA635; - zrf = 64'h9140007FFFFFFEFF; - ans = 64'h9140007FFFFFFEFF; + x = 64'hC7FC0003FFFFFFFF; + y = 64'h3CCFFFFF80000000; + z = 64'hBFB000800001FFFF; + ans = 64'hC4DC00038FFFEFFF; rn = 1; rz = 0; rm = 0; @@ -421883,19 +117274,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -421911,246 +117302,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5511263\n"); + $fwrite(fp,"5024929\n"); end - xrf = 64'hFFDFFFFFEFFEFFFF; - y = 64'hFFF0000000000000; - zrf = 64'h3CA0000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5511877\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hC01151453CAF399B; - zrf = 64'h380D252CB283583A; - ans = 64'h437151453CAF399A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5512491\n"); - end - xrf = 64'h7FE000FFBFFFFFFE; - y = 64'hFFF0000000000001; - zrf = 64'h2B7000013FFFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5513105\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'h3FE01DFFFFFFFFFF; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5513719\n"); - end - xrf = 64'h41E000007FFFF000; - y = 64'hC0F8793103CA557F; - zrf = 64'hBFDFDFFFFFFFFE00; - ans = 64'hC2E87931C793C534; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5514333\n"); - end - xrf = 64'hC34FFFFFFFFFFFFF; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'hFFF0000000000001; + x = 64'hC010000000000000; + y = 64'h001FFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -422165,19 +117321,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -422193,576 +117349,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5514947\n"); + $fwrite(fp,"5026943\n"); end - xrf = 64'h3FE0000000000300; - y = 64'h40A000000100000E; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'h408FF0000200061C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5515561\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h0000000000000001; - zrf = 64'hFFDEFFF800000000; - ans = 64'hFFDEFFF800000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5516175\n"); - end - xrf = 64'h40E000001003FFFE; - y = 64'hA60520BDC3001A33; - zrf = 64'hBFA0001800000000; - ans = 64'hBFA0001800000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5516789\n"); - end - xrf = 64'h001DBFFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h001FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5517403\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'hC3405FFFFFFFFFFE; - zrf = 64'h4042D7C32DE81107; - ans = 64'h46A05FFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5518017\n"); - end - xrf = 64'hBFA0001FFFFFFBFE; - y = 64'h0010000000000000; - zrf = 64'hBECFBFFFEFFFFFFE; - ans = 64'hBECFBFFFEFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5518631\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h802ABF3CAB85030B; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5519245\n"); - end - xrf = 64'h650FF60000000000; - y = 64'h400062711970E347; - zrf = 64'h3FC0000018000000; - ans = 64'h65205D525618F000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5519859\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5520473\n"); - end - xrf = 64'hC6800000000001FE; - y = 64'hFFFFE001FFFFFFFF; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hFFFFE001FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5521087\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h3CA0000000000000; - zrf = 64'h3FE03FFFFFFFFFBF; - ans = 64'hBFF7E0000000001E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5521701\n"); - end - xrf = 64'h4030FFFFFFFDFFFF; - y = 64'h801FFFFFFFFFF83E; - zrf = 64'h4E4000000FFDFFFF; - ans = 64'h4E4000000FFDFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5522315\n"); - end - xrf = 64'h37E7FFFFFFFFFFF0; + x = 64'hBFFEFC43BDEC594F; y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h34A7FFFFFFFFFFEF; + z = 64'hC1D0007FFFFF0000; + ans = 64'hC1D0007FFFFF0000; rn = 1; rz = 0; rm = 0; @@ -422776,19 +117368,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -422804,12 +117396,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5522929\n"); + $fwrite(fp,"5028957\n"); end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'hA7FA99986A7578FC; - zrf = 64'h469FEFFFF7FFFFFE; - ans = 64'h469FEFFFF7FFFFFE; + x = 64'h3FEFFFFFFFFFFFC3; + y = 64'h559E4A558F2A87B9; + z = 64'h37EFFBFEFFFFFFFF; + ans = 64'h559E4A558F2A877F; rn = 1; rz = 0; rm = 0; @@ -422823,19 +117415,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -422851,247 +117443,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5523543\n"); + $fwrite(fp,"5030971\n"); end - xrf = 64'h841DFFFF7FFFFFFF; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h6C9040003FFFFFFF; - ans = 64'h6C9040003FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5524157\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h41FFFE0000000001; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'hC55FFDFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5524771\n"); - end - xrf = 64'h43CF800004000000; - y = 64'h001FFC0003FFFFFF; - zrf = 64'h3FCFFFDFFFEFFFFF; - ans = 64'h3FCFFFDFFFEFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5525385\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h3FD0000000000001; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC353FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5525999\n"); - end - xrf = 64'hC0400000077FFFFE; - y = 64'h7FE8CFFC8A82F6C7; - zrf = 64'hBFE0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5526613\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; + x = 64'hC010000000000000; y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'hC4FFFFFFFFDFBFFF; - ans = 64'hC500000000EFDFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBFFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -423105,19 +117462,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -423133,153 +117490,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5527227\n"); + $fwrite(fp,"5032985\n"); end - xrf = 64'hBFD003FFFFC00000; - y = 64'h4030007FFFFFFFF6; - zrf = 64'h00253DF9CCA800F3; - ans = 64'hC01004801FBFFDF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5527841\n"); - end - xrf = 64'hC02FFFFFFFFFF8FE; - y = 64'h3FE0000000000001; - zrf = 64'h0000000000000000; - ans = 64'hC01FFFFFFFFFF900; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5528455\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h3E2FFFFFFDFBFFFF; - zrf = 64'h3C8001000000001E; - ans = 64'hC18FFFFFFDFBFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5529069\n"); - end - xrf = 64'hC07FFFFFAFFFFFFE; + x = 64'hC3F3FFFFFFFFFFEF; y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h3FFFFFFFFEFFFFFA; - ans = 64'hC07FDFFFB000FFFD; + z = 64'hC014BF12499BEAA6; + ans = 64'hC3F3FFFFFFFFFFEE; rn = 1; rz = 0; rm = 0; @@ -423293,19 +117509,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -423321,12 +117537,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5529683\n"); + $fwrite(fp,"5034999\n"); end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'hC002D8AC057439AD; - zrf = 64'h4010000000000000; - ans = 64'h4362D8AC057439AC; + x = 64'hFD6FFFFFFEFFFEFF; + y = 64'hC5600003FFFF0000; + z = 64'h6FF03FFFFFFFFFEF; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -423340,19 +117556,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -423368,247 +117584,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5530297\n"); + $fwrite(fp,"5037013\n"); end - xrf = 64'hC1600007FFFF7FFE; - y = 64'h4B527FFFFFFFFFFF; - zrf = 64'h9137FFFFF7FFFFFF; - ans = 64'hCCC280093FFF6BFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5530911\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h3FF0000000000000; - zrf = 64'hC340000000000000; - ans = 64'hC357FFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5531525\n"); - end - xrf = 64'h000000000001FFEF; - y = 64'h46E00000087FFFFF; - zrf = 64'hBFD0000000000001; - ans = 64'hBFD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5532139\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h57C0000020000080; - ans = 64'h57C0000020000080; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5532753\n"); - end - xrf = 64'h3CAC568431473DE2; - y = 64'h3810DC0169CBF27F; - zrf = 64'hC08FF0000000001F; - ans = 64'hC08FF0000000001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5533367\n"); - end - xrf = 64'h400FFFFFFFFFFDFC; + x = 64'hC010000000000000; y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; + z = 64'h3FF0000000000001; + ans = 64'hC01BFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -423622,19 +117603,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -423650,59 +117631,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5533981\n"); + $fwrite(fp,"5039027\n"); end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h402FFFFFFFC0007F; - zrf = 64'h3810002000000FFF; - ans = 64'hC38FFFFFFFC0007D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5534595\n"); - end - xrf = 64'h0012000000000001; + x = 64'h37FF6974A0A2DE26; y = 64'h4000000000000001; - zrf = 64'h000909A97B1F06A1; - ans = 64'h002684D4BD8F8353; + z = 64'h9EFD901931AB4FD9; + ans = 64'h380F6974A0A2DE28; rn = 1; rz = 0; rm = 0; @@ -423716,19 +117650,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -423744,12 +117678,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5535209\n"); + $fwrite(fp,"5041041\n"); end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h801FFFDF7FFFFFFE; - zrf = 64'h4000000000000001; - ans = 64'h4000000000000001; + x = 64'h43A00000017FFFFF; + y = 64'h002FFC000000000F; + z = 64'h47F56A050C6B635C; + ans = 64'h47F56A050C6B635C; rn = 1; rz = 0; rm = 0; @@ -423763,19 +117697,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -423791,247 +117725,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5535823\n"); + $fwrite(fp,"5043055\n"); end - xrf = 64'h43EFFFFF00002000; - y = 64'hB817FFFF80000000; - zrf = 64'h43D007FFFF7FFFFF; - ans = 64'h43D007FFFF7FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5536437\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hC010000000000001; - ans = 64'hC36FFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5537051\n"); - end - xrf = 64'h3FEF00000000000F; - y = 64'h9FFFFFF000000FFF; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'hBCAFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5537665\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h4010000000000001; - zrf = 64'h000080007FFFFFFE; - ans = 64'hC370000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5538279\n"); - end - xrf = 64'h4E7E50301E15E373; - y = 64'h7FDFEFFFFFFF7FFF; - zrf = 64'hBA2F8D91DBB3429A; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5538893\n"); - end - xrf = 64'hC3CF8BAEB7372A48; + x = 64'hC010000000000000; y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC340000000000010; rn = 1; rz = 0; rm = 0; @@ -424045,19 +117744,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -424073,12 +117772,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5539507\n"); + $fwrite(fp,"5045069\n"); end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h4003F808BB83836F; - zrf = 64'hC74000000001FFC0; - ans = 64'hC74000000001FFC0; + x = 64'h3F67C855AE00CE43; + y = 64'h4340000000000001; + z = 64'h43E6F149C1994369; + ans = 64'h43E6F14CBAA3F929; rn = 1; rz = 0; rm = 0; @@ -424092,19 +117791,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -424120,12 +117819,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5540121\n"); + $fwrite(fp,"5047083\n"); end - xrf = 64'h2CC003FFEFFFFFFE; - y = 64'h4340000000000000; - zrf = 64'hFFEFFFFFFFFFFFF9; - ans = 64'hFFEFFFFFFFFFFFF9; + x = 64'hBA5E0000000FFFFF; + y = 64'hC03FC000000001FE; + z = 64'hC80003FFFC000000; + ans = 64'hC80003FFFC000000; rn = 1; rz = 0; rm = 0; @@ -424139,19 +117838,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -424167,622 +117866,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5540735\n"); + $fwrite(fp,"5049097\n"); end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'hC09FFFEE00000000; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h43FFFFEDFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5541349\n"); - end - xrf = 64'h41DFBFFFFFFFFE00; - y = 64'h7FE00000000007F7; - zrf = 64'h213B7993844DC0B0; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5541963\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC6AFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5542577\n"); - end - xrf = 64'h3FDFFF00003FFFFF; - y = 64'hC01F800000000000; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'hC00F7F04003EFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5543191\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h7FE0000000000000; - zrf = 64'hBD0F00000000000E; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5543805\n"); - end - xrf = 64'hBFEF95697E570A7E; - y = 64'h47E91961E5417A94; - zrf = 64'h3EBA552E32EEFF5A; - ans = 64'hC7E8C5C7C44C5695; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5544419\n"); - end - xrf = 64'hBFFC000040000000; - y = 64'h7FE0000000000001; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hFFEC000040000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5545033\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'hC920080001FFFFFF; - zrf = 64'hC1D00200000000FF; - ans = 64'h4C80080001FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5545647\n"); - end - xrf = 64'hC0181C098FA13A79; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h401EFFFFFFFFDFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5546261\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h47F0800000003FFE; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'hCB50800000003FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5546875\n"); - end - xrf = 64'h41CFFFFC001FFFFE; - y = 64'h3FD3DFFFFFFFFFFF; - zrf = 64'h47EFFFFFFFF80000; - ans = 64'h47EFFFFFFFF80000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5547489\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h7FF0000000000001; - zrf = 64'hBFFFFFFFFFFFFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5548103\n"); - end - xrf = 64'h43E4AB62F20824EA; - y = 64'h37E00000000001C0; - zrf = 64'h8010000000000000; - ans = 64'h3BD4AB62F208272D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5548717\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h3FB07FFFFFFFFF7F; + x = 64'hC010000000000000; + y = 64'h7FEFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -424797,19 +117885,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -424825,12 +117913,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5549331\n"); + $fwrite(fp,"5051111\n"); end - xrf = 64'hB5DFFFFFEFBFFFFF; - y = 64'h3B0FFFFFFBFFFFFF; - zrf = 64'hB0C0000008000080; - ans = 64'hB100FFFFF6600008; + x = 64'hBFE339A58291C4AF; + y = 64'h7FF0000000000001; + z = 64'h52AFA392C17F0D10; + ans = 64'h7FF8000000000001; rn = 1; rz = 0; rm = 0; @@ -424844,19 +117932,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -424872,11 +117960,904 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5549945\n"); + $fwrite(fp,"5053125\n"); end - xrf = 64'h7FD0000000FFFFFB; - y = 64'h8000000000000000; - zrf = 64'hC340000000000000; + x = 64'h41F20CE452B1F68A; + y = 64'h00279A7CD560FECE; + z = 64'h3FFFFFE000040000; + ans = 64'h3FFFFFE000040000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5055139\n"); + end + x = 64'hC010000000000000; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5057153\n"); + end + x = 64'hC018080000000000; + y = 64'h8010000000000000; + z = 64'hBFDFFFFF800001FE; + ans = 64'hBFDFFFFF800001FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5059167\n"); + end + x = 64'h3F90B65D53ED7D74; + y = 64'h43EEF244B81AFC9D; + z = 64'hEA94A4603D3F58EA; + ans = 64'hEA94A4603D3F58EA; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5061181\n"); + end + x = 64'hC010000000000000; + y = 64'hBCA0000000000001; + z = 64'hBFF0000000000001; + ans = 64'hBFEFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5063195\n"); + end + x = 64'h415FFFFDFFDFFFFF; + y = 64'hBFD0000000000000; + z = 64'hBA2FFFFFFFFFFF3E; + ans = 64'hC13FFFFDFFDFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5065209\n"); + end + x = 64'hC01DFFFFFFFFFF80; + y = 64'h434794F52A5C4334; + z = 64'hBFEFFFFC7FFFFFFE; + ans = 64'hC3761BA5D7B67EA2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5067223\n"); + end + x = 64'hC010000000000000; + y = 64'hBFE0000000000001; + z = 64'h4340000000000000; + ans = 64'h4340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5069237\n"); + end + x = 64'h002FFC0080000000; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hC03FF3FFFFFFFFFF; + ans = 64'hC03FF3FFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5071251\n"); + end + x = 64'h403FFFFFFFFFFFDB; + y = 64'h423356B030815738; + z = 64'hBF9080007FFFFFFF; + ans = 64'h428356B030815701; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5073265\n"); + end + x = 64'hC010000000000000; + y = 64'hC000000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5075279\n"); + end + x = 64'h480000100001FFFE; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hBFCAFAB20C86E4F5; + ans = 64'hC82000100001FFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5077293\n"); + end + x = 64'h41A69AC8BDFDB461; + y = 64'hC3D0083FFFFFFFFF; + z = 64'h41D8313B8D51B193; + ans = 64'hC586A6708D7FAB31; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5079307\n"); + end + x = 64'hC010000000000000; + y = 64'hC340000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h4360000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5081321\n"); + end + x = 64'h76FFFFFFFDFFFF7F; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h000000FFF7FFFFFF; + ans = 64'hFA5FFFFFFDFFFF7D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5083335\n"); + end + x = 64'h401000FFFFFFFFFF; + y = 64'h4BA80119D03CC382; + z = 64'h800FE0000000001E; + ans = 64'h4BC80299E1D9C74D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5085349\n"); + end + x = 64'hC010000000000000; + y = 64'hFFF0000000000000; + z = 64'h3FF0000000000001; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5087363\n"); + end + x = 64'h3D1100FFFFFFFFFF; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h4130200000000020; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5089377\n"); + end + x = 64'hC0300000007FFFFF; + y = 64'h801FFFFFFFF80FFF; + z = 64'h3F80080FFFFFFFFF; + ans = 64'h3F80080FFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5091391\n"); + end + x = 64'hC010000000000001; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hC340000000000000; ans = 64'hC340000000000000; rn = 1; rz = 0; @@ -424891,19 +118872,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -424919,12 +118900,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5550559\n"); + $fwrite(fp,"5093405\n"); end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h43D0000000000088; - zrf = 64'h182FFFFFB0000000; - ans = 64'hC730000000000087; + x = 64'h3B0000801FFFFFFF; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hC0B0000000EFFFFF; + ans = 64'hC0B0000000EFFFFF; rn = 1; rz = 0; rm = 0; @@ -424938,19 +118919,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -424966,12 +118947,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5551173\n"); + $fwrite(fp,"5095419\n"); end - xrf = 64'h5CE0000006000000; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h802FFFFEFFFF8000; - ans = 64'h9D00000005FFFFFF; + x = 64'hC03FEFFFFFFFFFF0; + y = 64'h802000000000007A; + z = 64'h4000000000041FFF; + ans = 64'h4000000000041FFF; rn = 1; rz = 0; rm = 0; @@ -424985,19 +118966,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425013,12 +118994,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5551787\n"); + $fwrite(fp,"5097433\n"); end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'hC037FFFFDFFFFFFF; - zrf = 64'h3FE0000000000000; - ans = 64'h4397FFFFDFFFFFFE; + x = 64'hC010000000000001; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -425032,19 +119013,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425060,12 +119041,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5552401\n"); + $fwrite(fp,"5099447\n"); end - xrf = 64'h41FFFFDFFFFFFFFF; - y = 64'h240000001FFFFF00; - zrf = 64'hC3DFFFFFFFF000FF; - ans = 64'hC3DFFFFFFFF000FF; + x = 64'hC802BDB003FB32E9; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h8020088000000000; + ans = 64'hC7F2BDB003FB32E8; rn = 1; rz = 0; rm = 0; @@ -425079,19 +119060,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425107,12 +119088,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5553015\n"); + $fwrite(fp,"5101461\n"); end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h8010000000000000; - zrf = 64'hBFF0000000000000; - ans = 64'hBFF0000000000000; + x = 64'h543000200000003F; + y = 64'hC02D1293AAABC916; + z = 64'hBDDFFFFFFFFFFEBE; + ans = 64'hD46D12CDCFD31EE0; rn = 1; rz = 0; rm = 0; @@ -425126,19 +119107,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425154,12 +119135,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5553629\n"); + $fwrite(fp,"5103475\n"); end - xrf = 64'h48CFFC0000000008; - y = 64'h40001FFFDFFFFFFF; - zrf = 64'h8000000000000001; - ans = 64'h48E01DFBE0040003; + x = 64'hC010000000000001; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hC00FFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -425173,19 +119154,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425201,12 +119182,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5554243\n"); + $fwrite(fp,"5105489\n"); end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h8023C515E93A5FC2; - ans = 64'h037FFFFFFFFFFFFC; + x = 64'hCE598DADDC5729FE; + y = 64'h3FF0000000000001; + z = 64'h3810207FFFFFFFFE; + ans = 64'hCE598DADDC572A00; rn = 1; rz = 0; rm = 0; @@ -425220,19 +119201,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425248,12 +119229,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5554857\n"); + $fwrite(fp,"5107503\n"); end - xrf = 64'hC3FFFFFFFFFFFC07; - y = 64'hB2DFFFFFFFFF01FF; - zrf = 64'hBF8D4FF57A03BED2; - ans = 64'hBF8D4FF57A03BED2; + x = 64'h43FFFFFFBFFFFBFF; + y = 64'hC6054EA060D6C64D; + z = 64'hBD1FFFE000000007; + ans = 64'hCA154EA0363982E1; rn = 1; rz = 0; rm = 0; @@ -425267,19 +119248,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425295,12 +119276,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5555471\n"); + $fwrite(fp,"5109517\n"); end - xrf = 64'hBFFFFFFFFFFFC100; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'hC010000000000001; - ans = 64'hC010000000000001; + x = 64'hC010000000000001; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hC031000000000001; rn = 1; rz = 0; rm = 0; @@ -425314,19 +119295,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425342,12 +119323,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5556085\n"); + $fwrite(fp,"5111531\n"); end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h3EF72EF3FEB6471D; - zrf = 64'h43419D8DF51C68BD; - ans = 64'h43419D5F97346B50; + x = 64'h3DEFFE0000003FFF; + y = 64'h4010000000000001; + z = 64'h7FFFFFFFFFF7FFFF; + ans = 64'h7FFFFFFFFFF7FFFF; rn = 1; rz = 0; rm = 0; @@ -425361,19 +119342,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425389,12 +119370,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5556699\n"); + $fwrite(fp,"5113545\n"); end - xrf = 64'h3FF003FFFF7FFFFF; - y = 64'hBCA0000000000001; - zrf = 64'hB7F0000040000000; - ans = 64'hBCA003FFFF800000; + x = 64'h40AB72C184FC22A3; + y = 64'hC390000000002800; + z = 64'h0000000000040007; + ans = 64'hC44B72C184FC6742; rn = 1; rz = 0; rm = 0; @@ -425408,19 +119389,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425436,12 +119417,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5557313\n"); + $fwrite(fp,"5115559\n"); end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'hB81FFFFFFF7FFFFB; - zrf = 64'h3FD0000000000001; - ans = 64'h3FD0000000000001; + x = 64'hC010000000000001; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'hC36C000000000001; rn = 1; rz = 0; rm = 0; @@ -425455,19 +119436,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425483,12 +119464,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5557927\n"); + $fwrite(fp,"5117573\n"); end - xrf = 64'hC1DFFFFFFBFFFFEF; - y = 64'hC1DFEFFFBFFFFFFF; - zrf = 64'hA7B8D554934D88B7; - ans = 64'h43CFEFFFBC01FFF6; + x = 64'h3FE0003FFFFFFFDF; + y = 64'h7FE0000000000000; + z = 64'h3F0C99E416733E31; + ans = 64'h7FD0003FFFFFFFDF; rn = 1; rz = 0; rm = 0; @@ -425502,19 +119483,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425530,12 +119511,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5558541\n"); + $fwrite(fp,"5119587\n"); end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hBFE0000000000001; - ans = 64'h400BFFFFFFFFFFFC; + x = 64'h407FFFF7FBFFFFFF; + y = 64'hCA6FFFFFFFFFBFBF; + z = 64'h4030000840000000; + ans = 64'hCAFFFFF7FBFFBFBE; rn = 1; rz = 0; rm = 0; @@ -425549,19 +119530,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425577,12 +119558,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5559155\n"); + $fwrite(fp,"5121601\n"); end - xrf = 64'hC80E000000000004; - y = 64'hBFCFF7FFFFFFFFFE; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; + x = 64'hC010000000000001; + y = 64'h7FF0000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -425596,19 +119577,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425624,12 +119605,247 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5559769\n"); + $fwrite(fp,"5123615\n"); end - xrf = 64'hC34FFFFFFFFFFFFE; + x = 64'hBB82B0937960FD27; + y = 64'h8000000000000000; + z = 64'h0020120000000000; + ans = 64'h0020120000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5125629\n"); + end + x = 64'h3FE5EB855F64990C; + y = 64'hC3DFFFFFFFFF7F7E; + z = 64'hA2DFFFFF8000007F; + ans = 64'hC3D5EB855F644105; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5127643\n"); + end + x = 64'hC010000000000001; + y = 64'h8010000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5129657\n"); + end + x = 64'h75DFFFFFFFFFF806; + y = 64'hBCA0000000000000; + z = 64'h3E80001F7FFFFFFF; + ans = 64'hF28FFFFFFFFFF806; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5131671\n"); + end + x = 64'h4024BE018F92CCC8; + y = 64'hB817E6B3FFEB70F6; + z = 64'h427FBFBFFFFFFFFF; + ans = 64'h427FBFBFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5133685\n"); + end + x = 64'hC010000000000001; y = 64'hBFD0000000000001; - zrf = 64'hFFE20001FFFFFFFE; - ans = 64'hFFE20001FFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h4000000000000002; rn = 1; rz = 0; rm = 0; @@ -425643,19 +119859,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425671,12 +119887,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5560383\n"); + $fwrite(fp,"5135699\n"); end - xrf = 64'hBFF0000000000000; - y = 64'h801FFFFFDFFFFEFF; - zrf = 64'hC3EF8000FFFFFFFF; - ans = 64'hC3EF8000FFFFFFFF; + x = 64'hBC58A7F283B15AA6; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hC00FF7FFFFFFFEFF; + ans = 64'hC00FF7FFFFFFFEFF; rn = 1; rz = 0; rm = 0; @@ -425690,19 +119906,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425718,12 +119934,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5560997\n"); + $fwrite(fp,"5137713\n"); end - xrf = 64'hC230001100000000; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'h42200010FFF7FFFF; + x = 64'h213FFFC000002000; + y = 64'hBFC39F7F419ECA3B; + z = 64'h3E1FFDFFFFFFEFFE; + ans = 64'h3E1FFDFFFFFFEFFE; rn = 1; rz = 0; rm = 0; @@ -425737,19 +119953,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425765,12 +119981,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5561611\n"); + $fwrite(fp,"5139727\n"); end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h400FE000003FFFFF; - zrf = 64'hC342000003FFFFFF; - ans = 64'hC3723000009FFFFE; + x = 64'hC010000000000001; + y = 64'hBFF0000000000000; + z = 64'hC340000000000000; + ans = 64'hC33FFFFFFFFFFFFC; rn = 1; rz = 0; rm = 0; @@ -425784,19 +120000,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425812,12 +120028,1516 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5562225\n"); + $fwrite(fp,"5141741\n"); end - xrf = 64'hC343FFFFFFFDFFFF; + x = 64'h37EA3353806450BA; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hB803FFFFFFFFF7FF; + ans = 64'hB8108CD4E019102E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5143755\n"); + end + x = 64'hC7E69C5B6A0DA2F1; + y = 64'hFFE0000200000FFE; + z = 64'h41C030A162E322F9; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5145769\n"); + end + x = 64'hC010000000000001; + y = 64'hC010000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5147783\n"); + end + x = 64'hC1FFF7FFFFFFFE00; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hBF38000000000040; + ans = 64'h422FF7FFFFFFFDCE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5149797\n"); + end + x = 64'h3FD00004000001FE; + y = 64'h53E98944E3420553; + z = 64'h401000000807FFFF; + ans = 64'h53C9894B45934151; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5151811\n"); + end + x = 64'hC010000000000001; + y = 64'hFFE0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5153825\n"); + end + x = 64'hBFE0000000000000; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hB45C000008000000; + ans = 64'h7FDFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5155839\n"); + end + x = 64'h2A901FC000000000; + y = 64'h7DEFFFFFFFFFDEFE; + z = 64'h3AD000FFBFFFFFFF; + ans = 64'h68901FBFFFFFEF5E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5157853\n"); + end + x = 64'hC010000000000001; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5159867\n"); + end + x = 64'hC76FFFFC00003FFF; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hC80BFFFF7FFFFFFE; + ans = 64'hC80BFFFF7FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5161881\n"); + end + x = 64'h43FFFFFFFC000100; + y = 64'hFFEFFFC002000000; + z = 64'h43F00000007FFBFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5163895\n"); + end + x = 64'hC01FFFFFFFFFFFFF; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5165909\n"); + end + x = 64'hBDDA8046AB558986; + y = 64'h3CA0000000000001; + z = 64'h3FA000002000007F; + ans = 64'h3FA000002000007F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5167923\n"); + end + x = 64'hBCAFFFFDF7FFFFFE; + y = 64'h366FFFFFFE1FFFFF; + z = 64'hB20F000000000007; + ans = 64'hB3300002DB10000E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5169937\n"); + end + x = 64'hC01FFFFFFFFFFFFF; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5171951\n"); + end + x = 64'h9720000000000103; + y = 64'h3FE0000000000001; + z = 64'h401B8A2396EC8564; + ans = 64'h401B8A2396EC8564; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5173965\n"); + end + x = 64'hBFFFFFFFFF7F7FFE; + y = 64'hC003FFFFFFFFFFF6; + z = 64'hCEA3CAF6C0E272A7; + ans = 64'hCEA3CAF6C0E272A7; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5175979\n"); + end + x = 64'hC01FFFFFFFFFFFFF; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hC02FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5177993\n"); + end + x = 64'h3B2FFFFFFFEFFFFC; + y = 64'h4000000000000001; + z = 64'h43F0007FFFFFFC00; + ans = 64'h43F0007FFFFFFC00; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5180007\n"); + end + x = 64'hC1D001001FFFFFFE; + y = 64'h8021509C47E8A603; + z = 64'h3FC0007BFFFFFFFF; + ans = 64'h3FC0007BFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5182021\n"); + end + x = 64'hC01FFFFFFFFFFFFF; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'hC04F7FFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5184035\n"); + end + x = 64'hBF410509ACBE8DD0; + y = 64'h4340000000000000; + z = 64'hBDC007F7FFFFFFFF; + ans = 64'hC2910509ACBE8DD0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5186049\n"); + end + x = 64'hC34FFFFFDFFF8000; + y = 64'h3FF80007FFFFFFFF; + z = 64'hCA50000400000001; + ans = 64'hCA50000400000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5188063\n"); + end + x = 64'hC01FFFFFFFFFFFFF; + y = 64'h7FE0000000000001; + z = 64'hC340000000000000; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5190077\n"); + end + x = 64'hB4BFFFFC0000FFFF; + y = 64'h7FF0000000000000; + z = 64'hD5C7770CA9F353D1; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5192091\n"); + end + x = 64'h7B6E5B7D682D63C8; + y = 64'h41E0008007FFFFFF; + z = 64'hBE1ABB9F82864AF4; + ans = 64'h7D5E5C70534663E5; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5194105\n"); + end + x = 64'hC01FFFFFFFFFFFFF; + y = 64'h8000000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5196119\n"); + end + x = 64'h40631D93C28E029D; + y = 64'h8010000000000000; + z = 64'hC80CB4CE53B7E24E; + ans = 64'hC80CB4CE53B7E24E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5198133\n"); + end + x = 64'hBF40000804000000; + y = 64'h3CCFFFFF7FFEFFFE; + z = 64'hBE9000000FFFFFFF; + ans = 64'hBE90000010001FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5200147\n"); + end + x = 64'hC01FFFFFFFFFFFFF; + y = 64'hBCA0000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CD4000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5202161\n"); + end + x = 64'h423C64DF6CA8AA39; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h3FF1AE3AB5F11D36; + ans = 64'h3FF1AE1E5111B08D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5204175\n"); + end + x = 64'hBFC00007FFFFFFFD; + y = 64'h40EDFFFFFFFFFFFF; + z = 64'hCC402000000FFFFE; + ans = 64'hCC402000000FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5206189\n"); + end + x = 64'hC01FFFFFFFFFFFFF; y = 64'hBFE0000000000000; - zrf = 64'h8001845DD878707A; - ans = 64'h4333FFFFFFFDFFFF; + z = 64'hBFF0000000000001; + ans = 64'h4007FFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -425831,19 +121551,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425859,12 +121579,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5562839\n"); + $fwrite(fp,"5208203\n"); end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h41DC9183F0B160D3; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hC53C9183F0B160D1; + x = 64'h434B1104A80420DF; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hAF7FFFFFFFFFFFDA; + ans = 64'hC34B1104A80420DD; rn = 1; rz = 0; rm = 0; @@ -425878,19 +121598,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425906,12 +121626,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5563453\n"); + $fwrite(fp,"5210217\n"); end - xrf = 64'hC80FFFFFDFFFFFFB; - y = 64'hBC80003FF8000000; - zrf = 64'h8E7FFFA000000000; - ans = 64'h44A0003FE7FFC005; + x = 64'hFC70000000FFFFEF; + y = 64'h480000000000401F; + z = 64'h001AB256227249D3; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -425925,19 +121645,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -425953,11 +121673,3254 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5564067\n"); + $fwrite(fp,"5212231\n"); end - xrf = 64'hC34FFFFFFFFFFFFE; + x = 64'hC01FFFFFFFFFFFFF; + y = 64'hC000000000000000; + z = 64'h4340000000000000; + ans = 64'h4340000000000008; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5214245\n"); + end + x = 64'h3CB00000000FFFFF; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hC9EDFEFFFFFFFFFF; + ans = 64'hC9EDFEFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5216259\n"); + end + x = 64'h40C00000000101FF; + y = 64'hBCC0003FFFFFFFDF; + z = 64'h37E000000000FFFF; + ans = 64'hBD900040000101E2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5218273\n"); + end + x = 64'hC01FFFFFFFFFFFFF; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5220287\n"); + end + x = 64'hB7FC6F7E42E2497D; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h4340000000000022; + ans = 64'h4340000000000022; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5222301\n"); + end + x = 64'hC28A5C919019FE50; + y = 64'hB7EFFFFFFFC3FFFF; + z = 64'hFFE03FDFFFFFFFFF; + ans = 64'hFFE03FDFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5224315\n"); + end + x = 64'hC01FFFFFFFFFFFFF; + y = 64'hFFEFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5226329\n"); + end + x = 64'hBFCFFFFFFFFFFF9E; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h7FF47307D935867F; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5228343\n"); + end + x = 64'hA7ABDC010B80E854; + y = 64'h40200F8000000000; + z = 64'h37E020000000003F; + ans = 64'h37E020000000003F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5230357\n"); + end + x = 64'hC01FFFFFFFFFFFFE; + y = 64'h000FFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5232371\n"); + end + x = 64'hBFFFFFFFFF0007FF; + y = 64'h0010000000000001; + z = 64'h5DBFFFF00003FFFF; + ans = 64'h5DBFFFF00003FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5234385\n"); + end + x = 64'hBF1FFFFFE0FFFFFF; + y = 64'hBFCFFFFFFBFFFF00; + z = 64'hBF9000001FFFFC00; + ans = 64'hBF8FF00040117800; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5236399\n"); + end + x = 64'hC01FFFFFFFFFFFFE; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5238413\n"); + end + x = 64'h3B0FFFFFF3FFFFFE; + y = 64'h3FD0000000000001; + z = 64'h3FBAB51472AC76F4; + ans = 64'h3FBAB51472AC76F4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5240427\n"); + end + x = 64'h47FE17F4025A7DEB; + y = 64'hB7F000000FFFFFEF; + z = 64'h41C000400000001F; + ans = 64'h41C0003FFF0F407E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5242441\n"); + end + x = 64'hC01FFFFFFFFFFFFE; + y = 64'h3FEFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5244455\n"); + end + x = 64'h8010000000803FFF; + y = 64'h3FF0000000000001; + z = 64'h000FFFE07FFFFFFF; + ans = 64'h8000001F80804001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5246469\n"); + end + x = 64'h3FEEFFFFFFBFFFFF; + y = 64'h43DFFC7AA40EA2B0; + z = 64'hC0300080000007FE; + ans = 64'h43DEFC96CEAE34A4; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5248483\n"); + end + x = 64'hC01FFFFFFFFFFFFE; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hC03FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5250497\n"); + end + x = 64'hBCA000000003FFFB; + y = 64'h4010000000000000; + z = 64'h3FDDFFFFFFFFFE00; + ans = 64'h3FDDFFFFFFFFFDF8; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5252511\n"); + end + x = 64'hBFBFFFFFF00001FF; + y = 64'h3BEFFFFEBFFFFFFE; + z = 64'h47E0020000003FFF; + ans = 64'h47E0020000003FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5254525\n"); + end + x = 64'hC01FFFFFFFFFFFFE; + y = 64'h4340000000000001; + z = 64'hBFF0000000000001; + ans = 64'hC370000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5256539\n"); + end + x = 64'hA87FFFFFF0001000; + y = 64'h7FE0000000000000; + z = 64'hC1F003FFFF000000; + ans = 64'hE86FFFFFF0001000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5258553\n"); + end + x = 64'hE388AAEF1804ADFA; + y = 64'h3F8FFFFFFF007FFF; + z = 64'hC05003FFFFFFFEFF; + ans = 64'hE328AAEF173FB92C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5260567\n"); + end + x = 64'hC01FFFFFFFFFFFFE; + y = 64'h7FF0000000000001; + z = 64'h4340000000000000; + ans = 64'h7FF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5262581\n"); + end + x = 64'h2C073FDF00CBB813; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hBFC0400000001FFF; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5264595\n"); + end + x = 64'h3FFEFFFEFFFFFFFF; + y = 64'h38100002FFFFFFFE; + z = 64'hB81EFFFF7FFFFFFF; + ans = 64'h36F53FFF3FF08000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5266609\n"); + end + x = 64'hC01FFFFFFFFFFFFE; + y = 64'h8010000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5268623\n"); + end + x = 64'h41CBFFFFFFFFEFFF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h3B3FFFFFFFFBFFFF; + ans = 64'h3B3FFFFFFFFBFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5270637\n"); + end + x = 64'hB7FB47A039F47B8F; + y = 64'hC012D33A35DF82B8; + z = 64'h3FC03D9B3C90E530; + ans = 64'h3FC03D9B3C90E530; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5272651\n"); + end + x = 64'hC01FFFFFFFFFFFFE; + y = 64'hBFD0000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h3FFFFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5274665\n"); + end + x = 64'hC1C07FFFFFFFFFFF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h42DB2D4BE861DF6A; + ans = 64'h42DB2D500861DF6A; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5276679\n"); + end + x = 64'h41CDFFFFC0000000; + y = 64'hBFBFF87FFFFFFFFE; + z = 64'h41C000000080FFFF; + ans = 64'h41B881C210FE3FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5278693\n"); + end + x = 64'hC01FFFFFFFFFFFFE; + y = 64'hBFF0000000000000; + z = 64'h3FF0000000000001; + ans = 64'h4021FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5280707\n"); + end + x = 64'h41DFFA0EFC62A2B5; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'hFFFFC000000FFFFE; + ans = 64'hFFFFC000000FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5282721\n"); + end + x = 64'hA6EF808000000000; + y = 64'hC3F97BC58770EB17; + z = 64'hC1E020001FFFFFFE; + ans = 64'hC1E020001FFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5284735\n"); + end + x = 64'hC01FFFFFFFFFFFFE; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'hC33FFFFFFFFFFFE0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5286749\n"); + end + x = 64'h3FE000000040003F; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h3C7FFC01FFFFFFFF; + ans = 64'hC01000000040003E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5288763\n"); + end + x = 64'h480FFC07FFFFFFFE; + y = 64'h3C000000001FFFEF; + z = 64'hBFBFFF0007FFFFFF; + ans = 64'h441FFC08003FF7EC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5290777\n"); + end + x = 64'hC01FFFFFFFFFFFFE; + y = 64'hC34FFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5292791\n"); + end + x = 64'h002DFFFEFFFFFFFF; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h3FFFFFFFFFFFFBFC; + ans = 64'hC029FFFF0000007F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5294805\n"); + end + x = 64'h3FE8080000000000; + y = 64'hB677FFDFFFFFFFFE; + z = 64'h801FFFFFFFFFFFD8; + ans = 64'hB67205E7F7FFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5296819\n"); + end + x = 64'hC01FFFFFFFFFFFFE; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5298833\n"); + end + x = 64'hBFC75F2E65F71048; + y = 64'h0000000000000001; + z = 64'h400FFFFFFFFFFDFE; + ans = 64'h400FFFFFFFFFFDFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5300847\n"); + end + x = 64'hC383F50A0CB6ED42; + y = 64'h41EB3DD4A3B7B79C; + z = 64'hC189841022924E71; + ans = 64'hC580FD50335FE825; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5302861\n"); + end + x = 64'hC340000000000000; + y = 64'h001FFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5304875\n"); + end + x = 64'hAB6FFFFFFFEBFFFF; + y = 64'h3CA0000000000001; + z = 64'h4027FFF000000000; + ans = 64'h4027FFF000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5306889\n"); + end + x = 64'h43E0FDBF1FC3A391; + y = 64'h3FEFFFDFFFFFFFFD; + z = 64'h7FF01F0D90902767; + ans = 64'h7FF81F0D90902767; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5308903\n"); + end + x = 64'hC340000000000000; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h4330000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5310917\n"); + end + x = 64'hBCAFFFC0001FFFFE; + y = 64'h3FE0000000000000; + z = 64'hBFC000400000000F; + ans = 64'hBFC0004000000013; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5312931\n"); + end + x = 64'h3B400000000101FF; + y = 64'h3F301000000FFFFF; + z = 64'h3FE000040003FFFE; + ans = 64'h3FE000040003FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5314945\n"); + end + x = 64'hC340000000000000; + y = 64'h3FF0000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5316959\n"); + end + x = 64'hC1FFFFFFFFFF3FFE; + y = 64'h4000000000000000; + z = 64'h802FE01FFFFFFFFF; + ans = 64'hC20FFFFFFFFF3FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5318973\n"); + end + x = 64'hC030001FFFFEFFFF; + y = 64'hBE800000007FBFFF; + z = 64'hD16000000006FFFF; + ans = 64'hD16000000006FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5320987\n"); + end + x = 64'hC340000000000000; + y = 64'h4010000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hC360000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5323001\n"); + end + x = 64'h20E800000000003F; + y = 64'h4340000000000000; + z = 64'hFFDB256EE305E7EE; + ans = 64'hFFDB256EE305E7EE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5325015\n"); + end + x = 64'h7BFFF8003FFFFFFE; + y = 64'h1FB0000000000BFF; + z = 64'hBFB0000060000000; + ans = 64'h5BBFF800400017F6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5327029\n"); + end + x = 64'hC340000000000000; + y = 64'h7FE0000000000001; + z = 64'h3FF0000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5329043\n"); + end + x = 64'h43F4063A60BE557D; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h401D88A3C8A4CC8C; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5331057\n"); + end + x = 64'h3FCFFFFFFEFFFFEF; + y = 64'h37F8C27C91B78B6B; + z = 64'hC780000001EFFFFE; + ans = 64'hC780000001EFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5333071\n"); + end + x = 64'hC340000000000000; + y = 64'h8000000000000000; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5335085\n"); + end + x = 64'h257E2D1C6CE4BD4E; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h43D3EC126AA24CBC; + ans = 64'h43D3EC126AA24CBC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5337099\n"); + end + x = 64'h47F24F55280F21A5; + y = 64'hC1D2E757751DE923; + z = 64'hBC76E5E152B15135; + ans = 64'hC9D5A1FD3FE8C36C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5339113\n"); + end + x = 64'hC340000000000000; + y = 64'hBCA0000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5341127\n"); + end + x = 64'h43F017FFFFFFFFFE; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hC01EFFFFFFFFEFFF; + ans = 64'hC0B01FBFFFFFFFF9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5343141\n"); + end + x = 64'hBF9B000000000000; + y = 64'h37EFFFFFFEFFF7FF; + z = 64'h3BDFFF8000000FFF; + ans = 64'h3BDFFF8000000FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5345155\n"); + end + x = 64'hC340000000000000; + y = 64'hBFE0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h4330000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5347169\n"); + end + x = 64'h4128574D5C8F3538; y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hBFDFFFFFFFFFFFFF; + z = 64'hC3EBFD9EE3D633DB; + ans = 64'hC3EBFD9EE3D63560; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5349183\n"); + end + x = 64'hBFDFF70000000000; + y = 64'h361C00000000003F; + z = 64'h400FFFFFBBFFFFFF; + ans = 64'h400FFFFFBBFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5351197\n"); + end + x = 64'hC340000000000000; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'hBFF0000000000001; ans = 64'h434FFFFFFFFFFFFD; rn = 1; rz = 0; @@ -425972,19 +124935,4954 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5353211\n"); + end + x = 64'hC02FFFFFFFC0000F; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'h43F03BFFFFFFFFFF; + ans = 64'h43F03BFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5355225\n"); + end + x = 64'h47FFF6FFFFFFFFFF; + y = 64'hC00000010000003F; + z = 64'hC3F00000000BFFFF; + ans = 64'hC80FF701FF70007D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5357239\n"); + end + x = 64'hC340000000000000; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h4371FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5359253\n"); + end + x = 64'hB7F010000FFFFFFF; + y = 64'hC340000000000001; + z = 64'hB336E0808B4E505D; + ans = 64'h3B40100010000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5361267\n"); + end + x = 64'h4DF000001FFFFDFF; + y = 64'hC010010000000003; + z = 64'h41BFFC00000001FF; + ans = 64'hCE1001002001FE02; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5363281\n"); + end + x = 64'hC340000000000000; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5365295\n"); + end + x = 64'h3FB00007FFFFFFF7; + y = 64'hFFF0000000000001; + z = 64'hC3CE7914194C95AE; + ans = 64'hFFF8000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5367309\n"); + end + x = 64'hC6DFBFFFFFFE0000; + y = 64'h43F01FFFFFFFBFFE; + z = 64'h303FFF7FFFDFFFFF; + ans = 64'hCADFFF7FFFFD7CFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5369323\n"); + end + x = 64'hC340000000000001; + y = 64'h000FFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hBCAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5371337\n"); + end + x = 64'h3FBAC24425DCBA63; + y = 64'h0010000000000001; + z = 64'h41E90A03C7D2CD15; + ans = 64'h41E90A03C7D2CD15; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5373351\n"); + end + x = 64'h434FFC0020000000; + y = 64'h4780203FFFFFFFFF; + z = 64'hC02FFFFE000001FF; + ans = 64'h4AE01E3C08203FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5375365\n"); + end + x = 64'hC340000000000001; + y = 64'h3CAFFFFFFFFFFFFF; + z = 64'h3FF0000000000001; + ans = 64'hBFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5377379\n"); + end + x = 64'hBFC000000007FFFC; + y = 64'h3FD0000000000000; + z = 64'hC50000FFFF000000; + ans = 64'hC50000FFFF000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5379393\n"); + end + x = 64'h3A1001F800000000; + y = 64'h2CD2000000000007; + z = 64'hBFBCEA2C8D11FAEE; + ans = 64'hBFBCEA2C8D11FAEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5381407\n"); + end + x = 64'hC340000000000001; + y = 64'h3FE0000000000001; + z = 64'hC340000000000000; + ans = 64'hC348000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5383421\n"); + end + x = 64'hB062599EFD2E8D66; + y = 64'h3FF0000000000000; + z = 64'hBFFFFFFFFC000002; + ans = 64'hBFFFFFFFFC000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5385435\n"); + end + x = 64'h4030000000030000; + y = 64'hBFC0003FFFFE0000; + z = 64'h358FFFFFFFD00000; + ans = 64'hC00000400001000C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5387449\n"); + end + x = 64'hC340000000000001; + y = 64'h4000000000000001; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5389463\n"); + end + x = 64'hBFF0589B0B9001F8; + y = 64'h4010000000000000; + z = 64'h43E0FFFFFFFFC000; + ans = 64'h43E0FFFFFFFFC000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5391477\n"); + end + x = 64'h3F5FFFBBFFFFFFFF; + y = 64'hC7CF9FFFFFFFFFFE; + z = 64'hC3D03FFFFFFFFFEE; + ans = 64'hC73F9FBCCBFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5393491\n"); + end + x = 64'hC340000000000001; + y = 64'h4340000000000001; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hC690000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5395505\n"); + end + x = 64'hBF9FFFFFFFFFFF01; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hBE5FFFFE0001FFFE; + ans = 64'hC2FFFFFFFFFFFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5397519\n"); + end + x = 64'hBF9DFFFFBFFFFFFF; + y = 64'hBFD004000000FFFE; + z = 64'hB812B42897CAD968; + ans = 64'h3F7E077FBFF1DFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5399533\n"); + end + x = 64'hC340000000000001; + y = 64'h7FF0000000000000; + z = 64'hBFF0000000000001; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5401547\n"); + end + x = 64'hC34FFFFFFFFFFEFF; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'h3FD332C76836F8C2; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5403561\n"); + end + x = 64'h381FFFFFEFFFFFBF; + y = 64'hCF4FFFFFFFFFFF02; + z = 64'hFFDFFFFFDFFE0000; + ans = 64'hFFDFFFFFDFFE0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5405575\n"); + end + x = 64'hC340000000000001; + y = 64'h8010000000000000; + z = 64'h4340000000000000; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5407589\n"); + end + x = 64'hC0A3E45119503FAD; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hB7FFFFC07FFFFFFF; + ans = 64'hB7FFFFC07FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5409603\n"); + end + x = 64'h3F5000000040001F; + y = 64'hB60FFFFFFFBFF7FF; + z = 64'hBE0004000000001F; + ans = 64'hBE0004000000001F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5411617\n"); + end + x = 64'hC340000000000001; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5413631\n"); + end + x = 64'hC15622341AA51F9D; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hC8000040000FFFFF; + ans = 64'hC8000040000FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5415645\n"); + end + x = 64'h47E00FFFF0000000; + y = 64'hC7E6114761B264AF; + z = 64'hB80010FFFFFFFFFF; + ans = 64'hCFD627589302CFB2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5417659\n"); + end + x = 64'hC340000000000001; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h4340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5419673\n"); + end + x = 64'hBFAFFD7FFFFFFFFE; + y = 64'hBFFFFFFFFFFFFFFF; + z = 64'h402FFFF400000000; + ans = 64'h40301FF780000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5421687\n"); + end + x = 64'h43E03FFFFFFEFFFE; + y = 64'hA51FFFFFFD000000; + z = 64'h41EFFFFFFF00FFFF; + ans = 64'h41EFFFFFFF00FFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5423701\n"); + end + x = 64'hC340000000000001; + y = 64'hC00FFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h4360000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5425715\n"); + end + x = 64'hC1D4FFFFFFFFFFFF; + y = 64'hC010000000000001; + z = 64'hB2700003DFFFFFFF; + ans = 64'h41F5000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5427729\n"); + end + x = 64'hB800007FFFFE0000; + y = 64'hFFFFFFFFFFFE7FFE; + z = 64'h7FF4000002000000; + ans = 64'hFFFFFFFFFFFE7FFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5429743\n"); + end + x = 64'hC340000000000001; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'hC340000000000000; + ans = 64'h46A0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5431757\n"); + end + x = 64'h3DC0007FFFFFFEFE; + y = 64'hFFE0000000000001; + z = 64'h480AECB2641E1823; + ans = 64'hFDB0007FFFFFFEFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5433771\n"); + end + x = 64'h3801FFFFFFE00000; + y = 64'h3FEFFFFEBFFFFFFF; + z = 64'hC342907ED9EA6975; + ans = 64'hC342907ED9EA6975; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5435785\n"); + end + x = 64'hC340000000000001; + y = 64'hFFFFFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5437799\n"); + end + x = 64'hBF924DEDD9119EE1; + y = 64'h0000000000000001; + z = 64'h2710000200000400; + ans = 64'h2710000200000400; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5439813\n"); + end + x = 64'hC002D684016B6C55; + y = 64'h33AFFFFFF0800000; + z = 64'h403FBDBE67E4A6F0; + ans = 64'h403FBDBE67E4A6F0; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5441827\n"); + end + x = 64'hC34FFFFFFFFFFFFF; + y = 64'h001FFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3CAFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5443841\n"); + end + x = 64'h801080000003FFFF; + y = 64'h3CA0000000000000; + z = 64'h4A6A29989E485F05; + ans = 64'h4A6A29989E485F05; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5445855\n"); + end + x = 64'h57A00000087FFFFF; + y = 64'hDAA1F96B0221DB2F; + z = 64'h4000200000000100; + ans = 64'hF251F96B0BAE5C07; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5447869\n"); + end + x = 64'hC34FFFFFFFFFFFFF; + y = 64'h3FD0000000000001; + z = 64'hBFF0000000000001; + ans = 64'hC330000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5449883\n"); + end + x = 64'hB70FFFFFFFFFFFF2; + y = 64'h3FE0000000000000; + z = 64'hCDF0000000100000; + ans = 64'hCDF0000000100000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5451897\n"); + end + x = 64'h420FFFFFFFFFFFFA; + y = 64'hC3C0004000001FFF; + z = 64'hBFCBFFFFFFFFFF7F; + ans = 64'hC5E0004000001FFC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5453911\n"); + end + x = 64'hC34FFFFFFFFFFFFF; + y = 64'h3FF0000000000001; + z = 64'h4340000000000000; + ans = 64'hC340000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5455925\n"); + end + x = 64'h92E00000007FFFFF; + y = 64'h3FFFFFFFFFFFFFFE; + z = 64'h4AAFFFFFFC001FFF; + ans = 64'h4AAFFFFFFC001FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5457939\n"); + end + x = 64'hC03000003FFDFFFF; + y = 64'h4034000000000002; + z = 64'h3FB0100000001000; + ans = 64'hC073FEFF4FFD8000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5459953\n"); + end + x = 64'hC34FFFFFFFFFFFFF; + y = 64'h4010000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5461967\n"); + end + x = 64'h41F003FFFFF00000; + y = 64'h401FFFFFFFFFFFFE; + z = 64'hCEA000007BFFFFFF; + ans = 64'hCEA000007BFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5463981\n"); + end + x = 64'h41DFFFFFFFFFFEFB; + y = 64'hBFEFFC0000000040; + z = 64'h41C07FFC00000000; + ans = 64'hC1D7BC01FFFFFF3B; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5465995\n"); + end + x = 64'hC34FFFFFFFFFFFFF; + y = 64'h7FE0000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5468009\n"); + end + x = 64'hC1DADF799416E178; + y = 64'h7FEFFFFFFFFFFFFE; + z = 64'h3F901FFFFFFFBFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5470023\n"); + end + x = 64'h4ACFFFFFFFE07FFF; + y = 64'h380111A0C92FBEE3; + z = 64'hBFC020EB7964E9DF; + ans = 64'h42E111A0C91EF184; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5472037\n"); + end + x = 64'hC34FFFFFFFFFFFFF; + y = 64'h8000000000000000; + z = 64'h3FF0000000000001; + ans = 64'h3FF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5474051\n"); + end + x = 64'hC09000003FFFC000; + y = 64'h800FFFFFFFFFFFFF; + z = 64'hC2BFFFFFFEFFFDFE; + ans = 64'hC2BFFFFFFEFFFDFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5476065\n"); + end + x = 64'hC3CC3FFFFFFFFFFF; + y = 64'h00200020000FFFFE; + z = 64'hC0B0E150163A077C; + ans = 64'hC0B0E150163A077C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5478079\n"); + end + x = 64'hC34FFFFFFFFFFFFF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hC340000000000000; + ans = 64'hC340000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5480093\n"); + end + x = 64'h59500000001FFEFE; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'h403BD6EEEFC0903B; + ans = 64'hD6100000001FFEFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5482107\n"); + end + x = 64'h000FFFFFFFFFFC00; + y = 64'h4030400040000000; + z = 64'h4033FFFFFFFE0000; + ans = 64'h4033FFFFFFFE0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5484121\n"); + end + x = 64'hC34FFFFFFFFFFFFF; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5486135\n"); + end + x = 64'hC1EFFFFFFFFC0003; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h41DF7FFFFFFFFBFF; + ans = 64'h41F7DFFFFFFDFF01; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5488149\n"); + end + x = 64'hC3EFFBFFFFFFFFDF; + y = 64'h403FFBFFFFFFFFFE; + z = 64'h380FFFFFFFFFFFE3; + ans = 64'hC43FF8007FFFFFDD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5490163\n"); + end + x = 64'hC34FFFFFFFFFFFFF; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h435FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5492177\n"); + end + x = 64'h4F8000000000083F; + y = 64'hC000000000000001; + z = 64'hBF49221D94699EAF; + ans = 64'hCF90000000000840; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5494191\n"); + end + x = 64'hC1E0000000009FFE; + y = 64'h43D00003FFFDFFFF; + z = 64'hC0346183422D9835; + ans = 64'hC5C00003FFFE9FFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5496205\n"); + end + x = 64'hC34FFFFFFFFFFFFF; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'h437FFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5498219\n"); + end + x = 64'h7FD0000800002000; + y = 64'hC340000000000001; + z = 64'hC98FFFFFFF9FFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5500233\n"); + end + x = 64'hBF5FFDFEFFFFFFFF; + y = 64'hC1C00000000007FE; + z = 64'hC068F8E52E02B635; + ans = 64'h412FFC6F71AD2FCF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5502247\n"); + end + x = 64'hC34FFFFFFFFFFFFF; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5504261\n"); + end + x = 64'h3FDEFFFFFFFFFFFF; + y = 64'hFFF0000000000000; + z = 64'h00021FFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5506275\n"); + end + x = 64'h43C00000000C0000; + y = 64'h3BA03FFFFFFFEFFE; + z = 64'hC19E0000000001FE; + ans = 64'hC19DFFFFFFFBF1FE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5508289\n"); + end + x = 64'hC34FFFFFFFFFFFFE; + y = 64'h0000000000000001; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5510303\n"); + end + x = 64'h800FFFFFFFFFFF00; + y = 64'h0010000000000000; + z = 64'hC0D00000C0000000; + ans = 64'hC0D00000C0000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5512317\n"); + end + x = 64'hB81EFFFFFFFFF7FF; + y = 64'h448FFFFFFF000007; + z = 64'h37FBCF34905D0CA7; + ans = 64'hBCBEFFFFFF07F806; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5514331\n"); + end + x = 64'hC34FFFFFFFFFFFFE; + y = 64'h3CA0000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hC000000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5516345\n"); + end + x = 64'hB80686567ADB6535; + y = 64'h3FD0000000000000; + z = 64'h402FFFFFFDFE0000; + ans = 64'h402FFFFFFDFE0000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5518359\n"); + end + x = 64'hC00595EBD72B467C; + y = 64'h43CF77FFFFFFFFFE; + z = 64'hC1E9531CB30BC1E8; + ans = 64'hC3E53A2EACF221AC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5520373\n"); + end + x = 64'hC34FFFFFFFFFFFFE; + y = 64'h3FE0000000000001; + z = 64'h3FF0000000000001; + ans = 64'hC33FFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5522387\n"); + end + x = 64'hC07FFBFFFFFFEFFF; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h43DEFFFFFF7FFFFE; + ans = 64'h43DEFFFFFF7FFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5524401\n"); + end + x = 64'hACFE3D603199179F; + y = 64'h4A90FFFFFFFFC000; + z = 64'h7FFC0005BF1C67B6; + ans = 64'h7FFC0005BF1C67B6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5526415\n"); + end + x = 64'hC34FFFFFFFFFFFFE; + y = 64'h4000000000000000; + z = 64'hC340000000000000; + ans = 64'hC363FFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5528429\n"); + end + x = 64'h3FA7FFFFFFE00000; + y = 64'h400FFFFFFFFFFFFE; + z = 64'h447FFFFFFFFFFFB6; + ans = 64'h447FFFFFFFFFFFB6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5530443\n"); + end + x = 64'hC01FFFF000001FFE; + y = 64'h419FFFBFFFFFFFFF; + z = 64'h4020088000000000; + ans = 64'hC1CFFFAFFC1DFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5532457\n"); + end + x = 64'hC34FFFFFFFFFFFFE; + y = 64'h4340000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5534471\n"); + end + x = 64'h43EB0FE627379F92; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h41FEFFFFFFFEFFFF; + ans = 64'h474B0FE627379F90; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5536485\n"); + end + x = 64'h3F00000003FF7FFF; + y = 64'h486FFFC01FFFFFFF; + z = 64'hC1D0000007FFFFFD; + ans = 64'h477FFFC027FEF007; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5538499\n"); + end + x = 64'hC34FFFFFFFFFFFFE; + y = 64'h7FF0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5540513\n"); + end + x = 64'h3FE300359974A384; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'h3F9B3495A3BE0D09; + ans = 64'h7FFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5542527\n"); + end + x = 64'hBF2FFFFC007FFFFF; + y = 64'hBFFA3248970AA8DD; + z = 64'hFFFFE0000001FFFE; + ans = 64'hFFFFE0000001FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5544541\n"); + end + x = 64'hC34FFFFFFFFFFFFE; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hBFF0000000000001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5546555\n"); + end + x = 64'h3FBFF0FFFFFFFFFE; + y = 64'h801FFFFFFFFFFFFF; + z = 64'hC3D040000000000F; + ans = 64'hC3D040000000000F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5548569\n"); + end + x = 64'hC3CDFFFFFFF7FFFF; + y = 64'hB805C95BB6EC1A60; + z = 64'hB7FAA09582D44A39; + ans = 64'h3BE46CC5FB77E662; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5550583\n"); + end + x = 64'hC34FFFFFFFFFFFFE; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'h4340000000000002; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5552597\n"); + end + x = 64'h3FF221640E87BBAD; + y = 64'hBFD0000000000001; + z = 64'hC1D70A764CFA4319; + ans = 64'hC1D70A764D0C647D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5554611\n"); + end + x = 64'h454FC00000000000; + y = 64'h406FE000000001FF; + z = 64'h41DF00000000FFFF; + ans = 64'h45CFA040000001FB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5556625\n"); + end + x = 64'hC34FFFFFFFFFFFFE; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5558639\n"); + end + x = 64'h3FFFFFFFFFFFF780; + y = 64'hBFF0000000000001; + z = 64'h400CFEFB818713C9; + ans = 64'h3FF9FDF7030E3010; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5560653\n"); + end + x = 64'hB80000000FFFFBFF; + y = 64'hFFEBC1EF4E485592; + z = 64'h42E2000800000000; + ans = 64'h77FBC1EF6A0A3DEE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5562667\n"); + end + x = 64'hC34FFFFFFFFFFFFE; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h436FFFFFFFFFFFFD; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -426002,10 +129900,10 @@ initial if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); $fwrite(fp,"5564681\n"); end - xrf = 64'h41FFFFFF7F7FFFFE; - y = 64'hC1E0000000100006; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; + x = 64'h37EFFFBFFBFFFFFE; + y = 64'hC010000000000001; + z = 64'h426FFFCFFFFFFFFF; + ans = 64'h426FFFCFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -426019,19 +129917,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -426047,12 +129945,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5565295\n"); + $fwrite(fp,"5566695\n"); end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'hBFF0000000000000; - zrf = 64'h487FFEFFFFFFFFF8; - ans = 64'h487FFEFFFFFFFFF8; + x = 64'hC3C7979FC93CF795; + y = 64'hC01FFFFDFFEFFFFF; + z = 64'hC72FFFDFFFFFBFFF; + ans = 64'hC72FFFDFFFFFBFFC; rn = 1; rz = 0; rm = 0; @@ -426066,19 +129964,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -426094,811 +129992,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5565909\n"); + $fwrite(fp,"5568709\n"); end - xrf = 64'hC272D6ADA89837EC; - y = 64'h40300002000FFFFF; - zrf = 64'h423394DC6A43C74F; - ans = 64'hC2B2C31B27167FE4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5566523\n"); - end - xrf = 64'h4040000000003F80; - y = 64'hBFF0000000000001; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hC041000000003F81; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5567137\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h3FFFFEFFFFFFFFFC; - zrf = 64'h41CF010A36B4AC15; - ans = 64'hC35FFEFFF07F7ADF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5567751\n"); - end - xrf = 64'h8020000020000800; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hBCA00010001FFFFF; - ans = 64'hBCA00010001FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5568365\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'hC1AFFFF800000010; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h450FFFF80000000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5568979\n"); - end - xrf = 64'h3FFFFFFFFFFFFFFF; - y = 64'hC5E8388E69DB0C78; - zrf = 64'hC1CB92A619BD23B0; - ans = 64'hC5F8388E69DB0C77; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5569593\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'hC000000000000001; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'h4360000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5570207\n"); - end - xrf = 64'hACF00FFFFFFFFFBF; - y = 64'hBFF000000000401F; - zrf = 64'h7FE0000000000000; - ans = 64'h7FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5570821\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h41F0003FFFDFFFFE; - ans = 64'h4370000010003FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5571435\n"); - end - xrf = 64'hB7EFFFFFFE7FFFFF; - y = 64'h42309FFFFFFFFFFF; - zrf = 64'hBFDFFFFDFFFFF7FF; - ans = 64'hBFDFFFFDFFFFF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5572049\n"); - end - xrf = 64'h43D88B4F419C8653; - y = 64'hC010000000000000; - zrf = 64'hBFF0000000000000; - ans = 64'hC3F88B4F419C8653; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5572663\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'hC1F00007FFFFFFFF; - zrf = 64'h932FFFFFFFFFF07F; - ans = 64'h45500007FFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5573277\n"); - end - xrf = 64'hC3D002FFFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hC3401000000000FE; - ans = 64'h440001FEFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5573891\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'hBFA051480852A469; - zrf = 64'h0010000000000000; - ans = 64'h430051480852A468; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5574505\n"); - end - xrf = 64'h4001B66E53F4513C; - y = 64'h4D94000000000002; - zrf = 64'hC09000003FEFFFFE; - ans = 64'h4DA62409E8F1658D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5575119\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'hC340000000000000; - zrf = 64'hBCA0000000000000; - ans = 64'h469FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5575733\n"); - end - xrf = 64'hC1ED67B2CEE357CB; - y = 64'h3FE6DF671E6AB9F4; - zrf = 64'h4340000000000001; - ans = 64'h433FFFFF57DB5D52; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5576347\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; + x = 64'hC34FFFFFFFFFFFFE; y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hFFD03FFFFFE00000; - ans = 64'hFFD03FFFFFE00000; + z = 64'h3FF0000000000001; + ans = 64'h46AFFFFFFFFFFFFD; rn = 1; rz = 0; rm = 0; @@ -426912,19 +130011,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -426940,12 +130039,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5576961\n"); + $fwrite(fp,"5570723\n"); end - xrf = 64'hC80FF00000000000; - y = 64'hC3CFFFF01FFFFFFE; - zrf = 64'hC1D00803FFFFFFFE; - ans = 64'h4BEFEFF027EFFFFE; + x = 64'hB7F70C049E6A16AF; + y = 64'hFFE0000000000000; + z = 64'hC02FFFFE7FFFFFFF; + ans = 64'h77E70C049E6A16AF; rn = 1; rz = 0; rm = 0; @@ -426959,19 +130058,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -426987,12 +130086,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5577575\n"); + $fwrite(fp,"5572737\n"); end - xrf = 64'hC1AFFFFFFFFEFDFE; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hBFE0000000000001; - ans = 64'h450FFFFFFFFEFDFC; + x = 64'hBF76A55146618FF8; + y = 64'hC2C000001FFFBFFE; + z = 64'h3FE000BFFFFFFFFE; + ans = 64'h4246A55173AC17F0; rn = 1; rz = 0; rm = 0; @@ -427006,19 +130105,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -427034,293 +130133,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5578189\n"); + $fwrite(fp,"5574751\n"); end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h47E00FFFFFFEFFFF; - zrf = 64'hBBE000200001FFFE; - ans = 64'hCB400FFFFFFEFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5578803\n"); - end - xrf = 64'hC03F8000000007FF; - y = 64'hFFE0000000000001; - zrf = 64'hBD7800000000FFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5579417\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h9330000084000000; - zrf = 64'h0000000000000001; - ans = 64'h1690000083FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5580031\n"); - end - xrf = 64'h002EFFFFFFFFFFFF; - y = 64'h400FFFFFFDFFBFFF; - zrf = 64'hBFD3CACDA9FAB407; - ans = 64'hBFD3CACDA9FAB407; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5580645\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h8010000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5581259\n"); - end - xrf = 64'h47E07FFFFFFFBFFF; - y = 64'h47EFFBFFFFFFFF7F; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h4FE07DEFFFFFBFC4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5581873\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; + x = 64'hC34FFFFFFFFFFFFE; y = 64'hFFF0000000000001; - zrf = 64'h802ACFCC0148C002; + z = 64'hC340000000000000; ans = 64'hFFF8000000000001; rn = 1; rz = 0; @@ -427335,19 +130152,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -427363,153 +130180,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5582487\n"); + $fwrite(fp,"5576765\n"); end - xrf = 64'hFFEFFFFFFEFFF800; - y = 64'h400F4C1A8C1956EA; - zrf = 64'h43CFFFFFFFBF7FFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5583101\n"); - end - xrf = 64'h43C0000037FFFFFE; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5583715\n"); - end - xrf = 64'hC34FFFFFFFFFFFFE; - y = 64'h416007FFFBFFFFFF; - zrf = 64'hFFE7ED132B80784E; - ans = 64'hFFE7ED132B80784E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5584329\n"); - end - xrf = 64'hBFD5774811A04632; + x = 64'hC1E0000000100010; y = 64'h0000000000000000; - zrf = 64'h43DC4536453C3752; - ans = 64'h43DC4536453C3752; + z = 64'h3F9FFDFFDFFFFFFF; + ans = 64'h3F9FFDFFDFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -427523,19 +130199,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -427551,12 +130227,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5584943\n"); + $fwrite(fp,"5578779\n"); end - xrf = 64'hFFE0000000000000; - y = 64'h3FC56EE584C4C29B; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; + x = 64'h40300000000023FE; + y = 64'h2212E1863EB8D556; + z = 64'h47EFE80D508843B7; + ans = 64'h47EFE80D508843B7; rn = 1; rz = 0; rm = 0; @@ -427570,19 +130246,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -427598,481 +130274,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5585557\n"); + $fwrite(fp,"5580793\n"); end - xrf = 64'hBFF200000000007E; - y = 64'h434FFFFF80007FFF; - zrf = 64'h27C0100400000000; - ans = 64'hC351FFFFB800487D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5586171\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'hBFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5586785\n"); - end - xrf = 64'h8000000000020FFF; - y = 64'h802FFFC000001FFF; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h400FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5587399\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h0010000000000000; - zrf = 64'h40001E2CDFA27B28; - ans = 64'h3F8E2CDFA27B2800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5588013\n"); - end - xrf = 64'h475FFFFEFDFFFFFE; - y = 64'h4341830A59AF936E; - zrf = 64'hFFE00007FFFF0000; - ans = 64'hFFE00007FFFF0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5588627\n"); - end - xrf = 64'h38FE00000007FFFF; + x = 64'hFFE0000000000000; y = 64'h0010000000000001; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'hBCAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5589241\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h3FE0009FFFFFFFFF; - zrf = 64'h401FFFFFBBFFFFFF; - ans = 64'hFFD0009FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5589855\n"); - end - xrf = 64'h3FC0000204000000; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hBFFF80000000001F; - ans = 64'hBFFF80000000001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5590469\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hBF6000001FEFFFFE; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFF7FFFFF007FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5591083\n"); - end - xrf = 64'h286FFFFFFFCFFFFF; - y = 64'hC3E7ABC06768839C; - zrf = 64'h43DFFFFFFFFFF7BF; - ans = 64'h43DFFFFFFFFFF7BF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5591697\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h3CA0000000000001; - zrf = 64'h7FFFFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -428087,19 +130293,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -428115,5229 +130321,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5592311\n"); + $fwrite(fp,"5582807\n"); end - xrf = 64'hC03FFFFF80007FFF; - y = 64'h4180FA45765319DE; - zrf = 64'h4000000000000000; - ans = 64'hC1D0FA4531EA47ED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5592925\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'hFFEAC37171B97759; - ans = 64'hFFEAC37171B9775A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5593539\n"); - end - xrf = 64'h40033C978C282E3D; - y = 64'h480BFFFBFFFFFFFF; - zrf = 64'hB5CC77796C170043; - ans = 64'h4820D502331036F0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5594153\n"); - end - xrf = 64'hC1C0000000020003; - y = 64'h3FD0000000000000; - zrf = 64'hBCA0000000000000; - ans = 64'hC1A0000000020003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5594767\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h4A90080000000100; - zrf = 64'hC0FFFFFE7FFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5595381\n"); - end - xrf = 64'hC00FFFF9FFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hC7F010000000000E; - ans = 64'hC7F010000000000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5595995\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h52410000001FFFFF; - zrf = 64'hFFE0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5596609\n"); - end - xrf = 64'hC7FFFFFFFFFF7FFD; - y = 64'h37F07FFFFFFFFFDF; - zrf = 64'hC02010000000003F; - ans = 64'hC0242FFFFFFFEFB6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5597223\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h3FE0000000000000; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5597837\n"); - end - xrf = 64'hBCA364C800C34AA5; - y = 64'hBFBEFFFFFF800000; - zrf = 64'h3FF0000000000001; - ans = 64'h3FF0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5598451\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h8021A60C0BE3AFB0; - ans = 64'hFFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5599065\n"); - end - xrf = 64'h2400000001007FFE; - y = 64'h7FE0000000FFC000; - zrf = 64'hFFD66C9394872434; - ans = 64'hFFD66C9394872434; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5599679\n"); - end - xrf = 64'hBFDFFFFFFFEFEFFE; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h8010000000000001; - ans = 64'hBFDFFFFFFFEFEFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5600293\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hC6BF007FFFFFFFFF; - zrf = 64'h8029E2363E2F5129; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5600907\n"); - end - xrf = 64'hB9BFFFFFFFC01FFF; - y = 64'h3FF0000000000001; - zrf = 64'hBE9400000FFFFFFE; - ans = 64'hBE9400000FFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5601521\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hC1F0007FFFFFFDFE; - zrf = 64'hC340000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5602135\n"); - end - xrf = 64'hC03A4C525F4ED141; - y = 64'h001FFFFFFFFFFFC0; - zrf = 64'hC3200000001FC000; - ans = 64'hC3200000001FC000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5602749\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h7FE0000000000001; - ans = 64'hFFDFFFFFFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5603363\n"); - end - xrf = 64'h4C92558B7D74B807; - y = 64'h4FCFF82000000000; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h5C7251087020D84E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5603977\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h4000000000000000; - zrf = 64'h41C07FFFFF7FFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5604591\n"); - end - xrf = 64'h3FB80007FFFFFFFF; - y = 64'h4B6FFFFFFFF77FFF; - zrf = 64'hC1D0010000FFFFFE; - ans = 64'h4B380007FFF99FFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5605205\n"); - end - xrf = 64'h4589A29376093867; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h45A9A29376093866; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5605819\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hB81000100000003E; - zrf = 64'hBFC3559D6C016458; - ans = 64'h780000100000003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5606433\n"); - end - xrf = 64'hC0300003F0000000; - y = 64'h4010000000000000; - zrf = 64'hC031FFFFFFDFFFFF; - ans = 64'hC0548003EFF80000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5607047\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hBF5B451B5C25A3A6; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'h7F4B451B5C25A3A6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5607661\n"); - end - xrf = 64'h40CFFFFE0000FFFF; - y = 64'h4340400000001FFE; - zrf = 64'h7FF01003FFFFFFFF; - ans = 64'h7FF81003FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5608275\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5608889\n"); - end - xrf = 64'hBFB8000000000007; - y = 64'hC00FF7FFFFFFFFDE; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FEBFCFFFFFFFFF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5609503\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h3DC0FFFFFFF80000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5610117\n"); - end - xrf = 64'hBFC0000003F7FFFE; - y = 64'h3F3903D08B47D3C4; - zrf = 64'hBFE8000000000FFE; - ans = 64'hBFE800640F4255EF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5610731\n"); - end - xrf = 64'h3FE07FBFFFFFFFFF; - y = 64'h4340000000000001; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5611345\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hFCDFFFFFFFFDBFFF; - zrf = 64'h80100000200007FE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5611959\n"); - end - xrf = 64'h47FFF7FEFFFFFFFE; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h37E3E14A71F21B43; - ans = 64'h4B5FF7FEFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5612573\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h403EB09115D7F623; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5613187\n"); - end - xrf = 64'h402E55EE82CBFF3E; - y = 64'hC3DFFFFD00000000; - zrf = 64'h3FD1FDFFFFFFFFFE; - ans = 64'hC41E55EBAABDA2FB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5613801\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h7FE0000000000001; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5614415\n"); - end - xrf = 64'hB80FFFFFFE01FFFF; - y = 64'h2E4FFFFFFFFFBFFF; - zrf = 64'h3FD0000000000000; - ans = 64'h3FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5615029\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h43FFFFFFFFF04000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5615643\n"); - end - xrf = 64'h7FDFFFFFFFFC3FFE; - y = 64'hC6F10000000007FF; - zrf = 64'hFFFFFFFFF00007FF; - ans = 64'hFFFFFFFFF00007FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5616257\n"); - end - xrf = 64'hD360C7754C14A45B; - y = 64'h7FF0000000000000; - zrf = 64'h7FF0000000000000; - ans = 64'hFFF8000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5616871\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hBC2F2C3C8676EB46; - zrf = 64'hFECFFFFEFFFBFFFE; - ans = 64'hFECFFFFEFFFBFC18; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5617485\n"); - end - xrf = 64'h406AB1E082251067; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'hC580000100001FFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5618099\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h43E0000000004000; - zrf = 64'hC000000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5618713\n"); - end - xrf = 64'h3ECFFFE00000003F; - y = 64'hBFD000000008007F; - zrf = 64'hBFEEA3D54E0F72A5; - ans = 64'hBFEEA3D74E0D72A6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5619327\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h8000000000000000; - zrf = 64'h4010000000000000; - ans = 64'h4010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5619941\n"); - end - xrf = 64'h801FFFFFFFFC2000; - y = 64'hCDEFC0FFFFFFFFFF; - zrf = 64'h3CA0000000000001; - ans = 64'h3CA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5620555\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h8000000000000001; - zrf = 64'hC03000000000003F; - ans = 64'hC03000000000003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5621169\n"); - end - xrf = 64'h40200000FFFFFFDF; - y = 64'hB400000000000220; - zrf = 64'h402000FFFFFF8000; - ans = 64'h402000FFFFFF8000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5621783\n"); - end - xrf = 64'h4150000020001FFF; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5622397\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hB7FFFFFBBFFFFFFF; - zrf = 64'h3FDFFFEFFFFFFFEF; - ans = 64'h77EFFFFBBFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5623011\n"); - end - xrf = 64'hC80000000101FFFF; - y = 64'h8010000000000000; - zrf = 64'h4CBA925386080C73; - ans = 64'h4CBA925386080C73; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5623625\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hFFDB586B241C00B4; - zrf = 64'hBFF0000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5624239\n"); - end - xrf = 64'h37BFFFFFFFC10000; - y = 64'h480FF7F7FFFFFFFF; - zrf = 64'hBFFFFFEFFFFFFFFF; - ans = 64'hBFF801F2000FBC0B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5624853\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h4000000000000001; - ans = 64'h4018000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5625467\n"); - end - xrf = 64'hC680FFFFFFFFF800; - y = 64'h46FFFFFFF0008000; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'hCD90FFFFF7803C00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5626081\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hBCA0000000000000; - zrf = 64'h43C00000FFFFFFFC; - ans = 64'h7C90000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5626695\n"); - end - xrf = 64'hBF800800000007FF; - y = 64'h3FEFFFFFFFFF3FFF; - zrf = 64'hC1530DDD40F869B3; - ans = 64'hC1530DDD4178A9B3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5627309\n"); - end - xrf = 64'h40E0001FFFFFFFFE; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5627923\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h3FF0010001000000; - zrf = 64'h403274B0F8ADC49A; - ans = 64'hFFE0010001000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5628537\n"); - end - xrf = 64'h3FFFF800000000FF; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h41EB3B0718997746; - ans = 64'h41EB3B0718997746; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5629151\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hC1EF800000001FFF; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5629765\n"); - end - xrf = 64'h3FA000000000007E; - y = 64'h41F4000FFFFFFFFF; - zrf = 64'h404000000010FFFE; - ans = 64'h41A400104000009D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5630379\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h7FCFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5630993\n"); - end - xrf = 64'hC03040000000003F; - y = 64'h4000047FFFFFFFFE; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'hC04044920000003D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5631607\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'hC1C7E52F77D96F90; - ans = 64'h7FCFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5632221\n"); - end - xrf = 64'h405520DC32F5850E; - y = 64'h2260020000000003; - zrf = 64'h41FFFE0008000000; - ans = 64'h41FFFE0008000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5632835\n"); - end - xrf = 64'hC02FFFFFFFDF7FFE; - y = 64'hBFE0000000000001; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h402FFFFFFFEFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5633449\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hC3C6037E6D3C7C48; - zrf = 64'hC3CFBFFFFFFFDFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5634063\n"); - end - xrf = 64'hC1C000001001FFFF; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h380FFFFBFFFFFFFE; - ans = 64'h41C000001001FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5634677\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h403FFFFFDFFFDFFF; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5635291\n"); - end - xrf = 64'h801FFFEFFFDFFFFF; - y = 64'h3FB6D519E32A6301; - zrf = 64'hC56FEFFFFFDFFFFF; - ans = 64'hC56FEFFFFFDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5635905\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hBFF0000000000001; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5636519\n"); - end - xrf = 64'h41CFFFDFFFF7FFFF; - y = 64'h380C13B159F6DC3D; - zrf = 64'h0000000000000000; - ans = 64'h39EC1395463E7D59; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5637133\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'hC3FFF3FFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5637747\n"); - end - xrf = 64'h41DA813F1F31D613; - y = 64'h36700000001007FF; - zrf = 64'h3FF0000000004FFF; - ans = 64'h3FF0000000004FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5638361\n"); - end - xrf = 64'h381FFFFFFC7FFFFF; - y = 64'hC000000000000000; - zrf = 64'h4010000000000000; - ans = 64'h4010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5638975\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hBFEFFFFFFFFFF7DE; - zrf = 64'hC02F000000FFFFFF; - ans = 64'h7FDFFFFFFFFFF7DE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5639589\n"); - end - xrf = 64'h406000000EFFFFFF; - y = 64'hC000000000000001; - zrf = 64'hC03FFFFEFFDFFFFF; - ans = 64'hC071FFFFFEFE0000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5640203\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h4793F7FFFFFFFFFF; - zrf = 64'hBFD0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5640817\n"); - end - xrf = 64'h480D5345B44A0BA3; - y = 64'h43400040003FFFFE; - zrf = 64'hC3C200003FFFFFFF; - ans = 64'h4B5D53BB01D629DE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5641431\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hC010000000000000; - zrf = 64'h3FE0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5642045\n"); - end - xrf = 64'h7FEFFFFFFFFFFFBF; - y = 64'h7FFA3BF60C60B6C7; - zrf = 64'hFFF0000000000001; - ans = 64'h7FFA3BF60C60B6C7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5642659\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hC010000000000001; - zrf = 64'h345400000000007E; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5643273\n"); - end - xrf = 64'hC513FFFFFBFFFFFF; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h41C0000000000000; - ans = 64'hC533FFFFFBFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5643887\n"); - end - xrf = 64'h3EFFFFF7FFFFE000; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h4000000000000001; - ans = 64'h3FFFFF0000400003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5644501\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hC350007FFFFFF800; - zrf = 64'hA253BC111EF78F75; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5645115\n"); - end - xrf = 64'hBCA0000FFFFDFFFF; - y = 64'hC340000000000000; - zrf = 64'hC3DFFFFE003FFFFE; - ans = 64'hC3DFFFFE003FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5645729\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h3FA00800000003FE; - zrf = 64'hBCA0000000000001; - ans = 64'hFF900800000003FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5646343\n"); - end - xrf = 64'hFFBFFFFFFFFF000F; - y = 64'hC022004000000000; - zrf = 64'h37FEECDD9EDBB39F; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5646957\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h3FD0000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5647571\n"); - end - xrf = 64'h40C0803FFFFFFFFF; - y = 64'hB470080010000000; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'hFFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5648185\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hFFE0000000000000; - zrf = 64'hFFE1FB8741CF3D02; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5648799\n"); - end - xrf = 64'h3CAA2E8AAA816D61; - y = 64'hC2A07C0000000000; - zrf = 64'h40BFF80000000400; - ans = 64'h40BFF7FF941A368B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5649413\n"); - end - xrf = 64'h59D0800007FFFFFE; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5650027\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h3CA000000000FFDF; - zrf = 64'hC68FFFFFFFFFF01F; - ans = 64'hFC9000000000FFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5650641\n"); - end - xrf = 64'hBF9FFF7FFFFFFFFD; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'hBFCD971B7F79A6B4; - ans = 64'h7F9FFF7FFFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5651255\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'h000FFFFC000001FF; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'hBFFFFFF8000003FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5651869\n"); - end - xrf = 64'hC1F497C0DC242B48; - y = 64'h3FF0000000087FFE; - zrf = 64'hBFE000000000002F; - ans = 64'hC1F497C0DC371BE4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5652483\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5653097\n"); - end - xrf = 64'h40FEF00000000000; - y = 64'h19960C8B2FB4769F; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hC34FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5653711\n"); - end - xrf = 64'hFFE0000000000000; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h40FFFFFFFFFFFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5654325\n"); - end - xrf = 64'hC06000000100003F; - y = 64'h7FFB9FB063DB52B1; - zrf = 64'h00102D3F222A96E9; - ans = 64'h7FFB9FB063DB52B1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5654939\n"); - end - xrf = 64'h4F6F8000003FFFFF; - y = 64'h0000000000000001; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'h3FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5655553\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h92CA34BB28C61266; - zrf = 64'h47EFFFFBFFF7FFFF; - ans = 64'h52BA34BB28C61268; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5656167\n"); - end - xrf = 64'hC1DDC28ED63F3C04; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'hB810080000003FFE; - ans = 64'hB810080000003FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5656781\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h7FE0203FFFFFFFFE; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5657395\n"); - end - xrf = 64'hC80FF7FFEFFFFFFF; - y = 64'hC3F372370C982F31; - zrf = 64'h46BFFFFFFFFFFBDF; - ans = 64'h4C136D5A751BED9E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5658009\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h0010000000000001; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'hC000000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5658623\n"); - end - xrf = 64'hBD807FFFF8000000; - y = 64'hA4400000087FFFFF; - zrf = 64'hC340000000000000; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5659237\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h400FFFFFFFFFEC00; - ans = 64'hBD84010000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5659851\n"); - end - xrf = 64'hBFB1F7FFFFFFFFFE; - y = 64'h1546C74A72BB6900; - zrf = 64'hC0AFFFFFF807FFFF; - ans = 64'hC0AFFFFFF807FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5660465\n"); - end - xrf = 64'h000FFFEFFFFFFEFF; + x = 64'hB051E706CE9D287D; y = 64'h3CA0000000000000; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE0000000000000; + z = 64'h401FFFF7FFFFC000; + ans = 64'h401FFFF7FFFFC000; rn = 1; rz = 0; rm = 0; @@ -433351,19 +130340,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -433379,12 +130368,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5661079\n"); + $fwrite(fp,"5584821\n"); end - xrf = 64'hFFE0000000000001; - y = 64'h7FEC9902C70CC225; - zrf = 64'hC26C14BC975A7841; - ans = 64'hFFF0000000000000; + x = 64'h43FFFFFFFFFFFF1F; + y = 64'hC7E1DD24871F44A6; + z = 64'h431DBB153CF092B9; + ans = 64'hCBF1DD24871F4428; rn = 1; rz = 0; rm = 0; @@ -433398,19 +130387,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -433426,152 +130415,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5661693\n"); + $fwrite(fp,"5586835\n"); end - xrf = 64'hFFFFFFFFF0007FFF; - y = 64'h3CA0000000000001; - zrf = 64'h0E63FFFFF8000000; - ans = 64'hFFFFFFFFF0007FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5662307\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hC01FFDFFFDFFFFFF; - zrf = 64'h8000000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5662921\n"); - end - xrf = 64'hA150800000000000; - y = 64'hA8500000000FFFFD; - zrf = 64'hC01DF83B106E7177; - ans = 64'hC01DF83B106E7177; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5663535\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h3FD0000000000000; - zrf = 64'h0010000000000000; + x = 64'hFFE0000000000000; + y = 64'h3FD0000000000001; + z = 64'h3CAFFFFFFFFFFFFF; ans = 64'hFFC0000000000001; rn = 1; rz = 0; @@ -433586,19 +130434,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -433614,153 +130462,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5664149\n"); + $fwrite(fp,"5588849\n"); end - xrf = 64'h402C000003FFFFFE; - y = 64'h41FFFFFFFF8000FE; - zrf = 64'hC010000000000001; - ans = 64'h423C0000038C00DC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5664763\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h3FD0000000000001; - zrf = 64'h37F07FFFFFFFBFFF; - ans = 64'hFFC0000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5665377\n"); - end - xrf = 64'hC00FFFFFFFFFDFEF; - y = 64'h7FFFFFFFFF900000; - zrf = 64'h3FA2000000000008; - ans = 64'h7FFFFFFFFF900000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5665991\n"); - end - xrf = 64'h41E07F7FFFFFFFFF; + x = 64'h095FFFEFFFFFEFFE; y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h3FD0000000000001; - ans = 64'h41D07F80000FFFFE; + z = 64'hB85664DBD796F697; + ans = 64'hB85664DBD796F697; rn = 1; rz = 0; rm = 0; @@ -433774,19 +130481,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -433802,12 +130509,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5666605\n"); + $fwrite(fp,"5590863\n"); end - xrf = 64'hFFE0000000000001; - y = 64'h4038ECC11B7A49F1; - zrf = 64'h4000001FFFFFF000; - ans = 64'hFFF0000000000000; + x = 64'h48F1000000200000; + y = 64'h404D000000000000; + z = 64'h41EAB80D34FBD97A; + ans = 64'h494ED000003A0000; rn = 1; rz = 0; rm = 0; @@ -433821,19 +130528,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -433849,2878 +130556,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5667219\n"); + $fwrite(fp,"5592877\n"); end - xrf = 64'h4110000000FFFFF7; - y = 64'h3FE0000000000000; - zrf = 64'h41900000000043FE; - ans = 64'h419008000000C3FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5667833\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hC1C000000000009E; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5668447\n"); - end - xrf = 64'hB7CFC00080000000; - y = 64'hBFC00001FFFFFFFB; - zrf = 64'hC1F0080000001FFF; - ans = 64'hC1F0080000001FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5669061\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h0000000000000001; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5669675\n"); - end - xrf = 64'h81B55E5743B57F69; - y = 64'hC1E0FFFFDFFFFFFE; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hC00FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5670289\n"); - end - xrf = 64'hFFE0000000000001; + x = 64'hFFE0000000000000; y = 64'h3FF0000000000000; - zrf = 64'hB800025D2C75D9B6; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5670903\n"); - end - xrf = 64'hC02FFEFFFDFFFFFF; - y = 64'hC3DFFFFFFEFFFF7E; - zrf = 64'h381FFFC000000FFF; - ans = 64'h441FFEFFFD00077D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5671517\n"); - end - xrf = 64'h402AFF3373721603; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h403AFF3373721602; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5672131\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h40DEFFFFEFFFFFFF; - zrf = 64'h43CFEFFFFFFFFF80; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5672745\n"); - end - xrf = 64'h4000D4606C6067CE; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hBFDFFFFC02000000; - ans = 64'h400DA8C15880CF9A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5673359\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h3CA0C6FE6997E5E2; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5673973\n"); - end - xrf = 64'h0FCFF7FFC0000000; - y = 64'h3FDFFFFFFBFFE000; - zrf = 64'h472E01FFFFFFFFFF; - ans = 64'h472E01FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5674587\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h4000000000000001; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5675201\n"); - end - xrf = 64'hBFDFFFFF8FFFFFFE; - y = 64'h3FCFFEFFFFFBFFFE; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hC000FFF7FC7FFBFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5675815\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h41FBFFFFFF800000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5676429\n"); - end - xrf = 64'h5B048232358520CE; - y = 64'h47F43239FE834329; - zrf = 64'h7FDFFDFFFFFF7FFF; - ans = 64'h7FDFFDFFFFFF7FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5677043\n"); - end - xrf = 64'hB8F00FFBFFFFFFFF; - y = 64'h4010000000000001; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'hB9100FFC00000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5677657\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hCB46165E46474EBB; - zrf = 64'hBDEFFFFFEFFF7FFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5678271\n"); - end - xrf = 64'hBFFFFEEFFFFFFFFE; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h802FFFFFFFE00003; - ans = 64'hC02FFEEFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5678885\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h4026B2F328969F7B; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5679499\n"); - end - xrf = 64'h41CFFFFFFFFFFF7C; - y = 64'hC03FFFFEFFFFFF7F; - zrf = 64'h37F9A545F3DC8A81; - ans = 64'hC21FFFFEFFFFFEFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5680113\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h4340000000000000; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5680727\n"); - end - xrf = 64'hC7E00000000023FF; - y = 64'hBFE0BCB9D8557D99; - zrf = 64'hBFF0000000000000; - ans = 64'h47D0BCB9D855A341; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5681341\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h3FDBFFF7FFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5681955\n"); - end - xrf = 64'hCFD000000002FFFF; - y = 64'h3C6FFFF000200000; - zrf = 64'hC02FFFFFBFFFFFFB; - ans = 64'hCC4FFFF00025FFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5682569\n"); - end - xrf = 64'hC02FFFFFEFFBFFFF; - y = 64'h7FE0000000000000; - zrf = 64'h0010000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5683183\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hB811000000200000; - zrf = 64'hB7EC310DAC6D16CE; - ans = 64'h7801000000200001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5683797\n"); - end - xrf = 64'h8027C5B45D2B3441; - y = 64'h7FE0000000000001; - zrf = 64'h47E40007FFFFFFFF; - ans = 64'h47E40007FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5684411\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h294FFD0000000000; - zrf = 64'h4340000000000000; - ans = 64'hE93FFD0000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5685025\n"); - end - xrf = 64'hD697FFFFFFFFFDFE; - y = 64'hB810000008000008; - zrf = 64'hC0000100003FFFFF; - ans = 64'h4EB800000BFFFE0A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5685639\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'hFFE0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5686253\n"); - end - xrf = 64'h4C8FFFFFFFFFFFFE; - y = 64'h3FE000043FFFFFFE; - zrf = 64'hBFE0000000000001; - ans = 64'h4C8000043FFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5686867\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h7FF0000000000001; - zrf = 64'hC04FFFFFFFFCFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5687481\n"); - end - xrf = 64'hC010000000010003; - y = 64'h6E70000000000300; - zrf = 64'h83D00000FFFFEFFE; - ans = 64'hEE90000000010303; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5688095\n"); - end - xrf = 64'hC000FFFFFFFFFBFF; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h0000000000000001; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5688709\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h4050000001FFF800; - zrf = 64'h4077FFFFFFFFBFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5689323\n"); - end - xrf = 64'hC34B7E6EEBBBE88F; - y = 64'h8000000000000000; - zrf = 64'h450000010000001E; - ans = 64'h450000010000001E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5689937\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h40EFFFFFF003FFFE; - zrf = 64'h4010000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5690551\n"); - end - xrf = 64'hA45F4756673783EC; - y = 64'h3745059EF5F9566A; - zrf = 64'h7FFFFFFFF0000800; - ans = 64'h7FFFFFFFF0000800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5691165\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'hC340000000000001; - ans = 64'hC340000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5691779\n"); - end - xrf = 64'hBFB6F4173CCBA909; - y = 64'h3FBFF0FFFFFFFFFF; - zrf = 64'hBFDFFFFFFFFFFFFF; - ans = 64'hBFE05BA553479CA6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5692393\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h8010000000000000; - zrf = 64'hC80D33BD32083113; - ans = 64'hC80D33BD32083113; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5693007\n"); - end - xrf = 64'hFFE00000000401FF; - y = 64'h43EF000040000000; - zrf = 64'h41FFFFDFFFFFFFFB; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5693621\n"); - end - xrf = 64'h380FFFFF7FF00000; - y = 64'h8010000000000001; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5694235\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hBE1FFFFFFE00FFFE; - zrf = 64'h400E00F8694D3D6B; - ans = 64'h7E0FFFFFFE010000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5694849\n"); - end - xrf = 64'h3FF8F7E043A8740F; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h483FFFFFBFFFFC00; - ans = 64'h483FFFFFBFFFFC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5695463\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hC03FFF8000003FFE; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5696077\n"); - end - xrf = 64'hC003FFEFFFFFFFFF; - y = 64'h4037FFFFFFFFFFFD; - zrf = 64'hAC7FC003FFFFFFFE; - ans = 64'hC04DFFE7FFFFFFFB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5696691\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hBCA0000000000001; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'h7C90000000000002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5697305\n"); - end - xrf = 64'hD8FD39CE403BB957; - y = 64'hBCA07FFFFFFFEFFF; - zrf = 64'hBCAFFFFFFFFFFFFE; - ans = 64'h55AE239CB23D79E6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5697919\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'hC01000000080007F; - ans = 64'h7CA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5698533\n"); - end - xrf = 64'h3FE000000000005E; - y = 64'h801FFEFFFFFFEFFE; - zrf = 64'h43E5FEC5C5844E1E; - ans = 64'h43E5FEC5C5844E1E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5699147\n"); - end - xrf = 64'hC038000000000007; - y = 64'hBFD0000000000000; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5699761\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hC340000000000404; - zrf = 64'h41E0001000007FFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5700375\n"); - end - xrf = 64'h960007FFFFFF7FFF; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hC1E083FFFFFFFFFF; - ans = 64'hC1E083FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5700989\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h434FFFF000100000; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5701603\n"); - end - xrf = 64'hC06DFFFFFFFFFFF8; - y = 64'hBF56B70E4D88D9DA; - zrf = 64'hBFAFFFFFFFB80000; - ans = 64'h3FD14B9D68B94C37; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5702217\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hBFE0000000000000; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'h7FD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5702831\n"); - end - xrf = 64'h47FFFFFFC0000FFE; - y = 64'h380000000000803F; - zrf = 64'hBCA0000000000000; - ans = 64'h400FFFFFC001107C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5703445\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'hB7EF07FFFFFFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5704059\n"); - end - xrf = 64'h3FAE000000000200; - y = 64'h0010000000004001; - zrf = 64'hBB432E7DB90517DF; - ans = 64'hBB432E7DB90517DF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5704673\n"); - end - xrf = 64'hBFB00000000FFFFF; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hFFE0000000000000; + z = 64'hBFF0000000000001; ans = 64'hFFE0000000000000; rn = 1; rz = 0; @@ -436735,19 +130575,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -436763,2831 +130603,105 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5705287\n"); + $fwrite(fp,"5594891\n"); end - xrf = 64'hFFE0000000000001; - y = 64'h43D88CC0EF298DED; - zrf = 64'h480000003FF00000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5705901\n"); - end - xrf = 64'hC1FB34F14E3AB1C1; - y = 64'hBFF0000000000001; - zrf = 64'hBFD00800000003FE; - ans = 64'h41FB34F14E36AFC3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5706515\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hB79F7FFFFFC00000; - zrf = 64'h3FF0000000000000; - ans = 64'h778F7FFFFFC00002; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5707129\n"); - end - xrf = 64'h3FF003C000000000; - y = 64'hBFC3A4FDCF733FA0; - zrf = 64'h42FDAD21FA49D91B; - ans = 64'h42FDAD21FA49D919; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5707743\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hC000000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5708357\n"); - end - xrf = 64'hC778000000020000; - y = 64'h686EFFFFFFFFFFFB; - zrf = 64'h8010000000000001; - ans = 64'hEFF740000001EFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5708971\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hC000000000000001; - zrf = 64'hBFDFFFFFFFFFFC0F; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5709585\n"); - end - xrf = 64'hBF1007FFFFFFFFFF; - y = 64'h43CFFFFFFF00001F; - zrf = 64'hBFFFFBFFFFFFFFF7; - ans = 64'hC2F007FFFF7FC02F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5710199\n"); - end - xrf = 64'hBFF003FFFFFFFFFE; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'hC340000000000001; - ans = 64'hC33FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5710813\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hC1B0008200000000; - zrf = 64'hC00C4D6700EF3F68; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5711427\n"); - end - xrf = 64'h3E5001FFFFFFFFEE; - y = 64'hC010000000000000; - zrf = 64'hC3DC507217BC45B1; - ans = 64'hC3DC507217BC45B1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5712041\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h401FFFFFFFCFFFFE; - zrf = 64'h3FE0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5712655\n"); - end - xrf = 64'h3FEFFFFFFFFFFFF6; - y = 64'h002007FFFFFEFFFF; - zrf = 64'h3AF000008000003E; - ans = 64'h3AF000008000003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5713269\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hBFF0000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5713883\n"); - end - xrf = 64'h000D7967734BE5E3; - y = 64'h3807FFFFFFFFFFF8; - zrf = 64'h800FFFFFFFFFFFFF; - ans = 64'h800FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5714497\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hC340000000000000; - zrf = 64'hC7F3FFFF7FFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5715111\n"); - end - xrf = 64'h43CFBFFFFFFFFFFB; - y = 64'h4A5D5618A16027E2; - zrf = 64'h43CF80000FFFFFFE; - ans = 64'h4E3D1B6C701D678E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5715725\n"); - end - xrf = 64'hC05E91F1DCA4DFC1; - y = 64'hC340000000000001; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'h43AE91F1DCA4DFC3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5716339\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'h78301000000000FF; - zrf = 64'hC00FDFFFFFFFFBFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5716953\n"); - end - xrf = 64'h4F66FFFFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'h4A2FFFFFFEFFFDFF; - ans = 64'hD2C6FFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5717567\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hC290003BFFFFFFFF; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5718181\n"); - end - xrf = 64'hC3FFFFFFFFC00000; - y = 64'h40E00037FFFFFFFE; - zrf = 64'hA56000007FFFFDFE; - ans = 64'hC4F00037FFDFFF8E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5718795\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hFFE0000000000001; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5719409\n"); - end - xrf = 64'h95AF000000008000; - y = 64'hC3CFF00000007FFE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5720023\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h7FE1000000010000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5720637\n"); - end - xrf = 64'h802FFFFFFFBFFFFF; - y = 64'h43F000001FFFFDFF; - zrf = 64'hB16001FFFFFFFFFF; - ans = 64'hB16001FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5721251\n"); - end - xrf = 64'h3FDFFFFFFFFFFFFF; - y = 64'hFFF0000000000000; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5721865\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hAB1B2667F3D89B46; - zrf = 64'h00107FFFFFFFFFF6; - ans = 64'h6B0B2667F3D89B48; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5722479\n"); - end - xrf = 64'h408FFFFFC03FFFFE; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'h4070000000007BFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5723093\n"); - end - xrf = 64'hFFE0000000000001; - y = 64'hC16FC003FFFFFFFF; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5723707\n"); - end - xrf = 64'h4099FD26ED60EBAE; - y = 64'h7FD26331A8A828D9; - zrf = 64'h3FE0000000003F00; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5724321\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h0000000000000000; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5724935\n"); - end - xrf = 64'hC8D00000003FFFFB; - y = 64'h280000000001003E; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5725549\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'h3FEFF00FFFFFFFFF; - ans = 64'hC00803FBFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5726163\n"); - end - xrf = 64'hC3400FDFFFFFFFFF; - y = 64'hB7E0000000083FFF; - zrf = 64'h409FFFFFF81FFFFF; - ans = 64'h409FFFFFF81FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5726777\n"); - end - xrf = 64'hB3DFFFE001FFFFFE; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hC000000000000000; - ans = 64'hC000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5727391\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h41DFFCFFFFFFFFFF; - zrf = 64'hC01F659605FED3D2; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5728005\n"); - end - xrf = 64'h41F300A6BF0B80D4; - y = 64'h0010000000000001; - zrf = 64'h384000007FFFFFBF; - ans = 64'h384000007FFFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5728619\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h3FC03FFFFDFFFFFF; - zrf = 64'h3CA0000000000000; - ans = 64'hFFC03FFFFDFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5729233\n"); - end - xrf = 64'hBFC2977D3A9BEAFB; - y = 64'h78F2000000000001; - zrf = 64'h43FABE5F75AA206D; - ans = 64'hF8C4EA6CE1EF685C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5729847\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hBFD0000000000000; - ans = 64'hC0207FFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5730461\n"); - end - xrf = 64'h2B1043FFFFFFFFFF; - y = 64'h402E000000000000; - zrf = 64'h7FE0000000000001; - ans = 64'h7FE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5731075\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h3CA0000000000001; - zrf = 64'hC7FFFFFFFFFEBFFF; - ans = 64'hFCA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5731689\n"); - end - xrf = 64'hFE2BC18FE370D42D; - y = 64'hB680003FFFFFFFF7; - zrf = 64'h25E00000003FFBFE; - ans = 64'h74BBC1FEE9B061E1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5732303\n"); - end - xrf = 64'hC01FF7FFFFFFBFFE; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hBFF0000000000001; - ans = 64'hBFF0000000000009; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5732917\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'hBD0B4E4969D36A55; - zrf = 64'hC1FFFFF8000003FF; - ans = 64'h7D0B4E4969D36A54; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5733531\n"); - end - xrf = 64'hC7FF4075BDC09731; - y = 64'h3FD0000000000000; - zrf = 64'hC0188B8A8BD20FA5; - ans = 64'hC7DF4075BDC09731; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5734145\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'hBCD4000000FFFFFF; - zrf = 64'h0010000000000001; - ans = 64'h7CD4000000FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5734759\n"); - end - xrf = 64'h3BF000000000403F; - y = 64'h5730005FFFFFFFFF; - zrf = 64'hC011C90B00A540A3; - ans = 64'h5330006000004040; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5735373\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hBCA0000000000001; - ans = 64'hFFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5735987\n"); - end - xrf = 64'hBC2F4368216E3B50; - y = 64'h00160AC6CDCE6F1B; - zrf = 64'h434FFFFFFFFFFFFF; - ans = 64'h434FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5736601\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h3FE0000000000000; - zrf = 64'hBE9E0000000001FF; - ans = 64'hFFDFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5737215\n"); - end - xrf = 64'h8024622F223BF578; - y = 64'hC12BFDFFFFFFFFFF; - zrf = 64'h3FAFFFFFFBFFBFFE; - ans = 64'h3FAFFFFFFBFFBFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5737829\n"); - end - xrf = 64'hC000FFFFF0000000; - y = 64'h3FE0000000000001; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hC0007FFFF8000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5738443\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'hBFCC1EABC1351C09; - zrf = 64'h5B9FC000007FFFFE; - ans = 64'h7FCC1EABC1351C08; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5739057\n"); - end - xrf = 64'h3BE0FFBFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h43C000008000007F; - ans = 64'h43C000008000007F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5739671\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'hC2E0002000040000; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5740285\n"); - end - xrf = 64'hC27C8BF4CEFD4B49; - y = 64'hC1F000003FEFFFFF; - zrf = 64'h3F10000000000047; - ans = 64'h447C8BF54110928E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5740899\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h3FF0000000000001; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5741513\n"); - end - xrf = 64'hC7EFFC3FFFFFFFFF; - y = 64'hBFCFFFFFFFFFDDFF; - zrf = 64'h401FFFFFFFFFFFFE; - ans = 64'h47CFFC3FFFFFDE02; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5742127\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; + x = 64'h40D4374FA828B57A; y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'hC7F0000080000020; + z = 64'hB08008000000000F; + ans = 64'h40E4374FA828B579; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5596905\n"); + end + x = 64'hBFFFFC00000001FE; + y = 64'hBE600000080FFFFE; + z = 64'h41FFFFFFFFFFF804; + ans = 64'h41FFFFFFFFFFF804; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5598919\n"); + end + x = 64'hFFE0000000000000; + y = 64'h4010000000000000; + z = 64'h4340000000000000; ans = 64'hFFF0000000000000; rn = 1; rz = 0; @@ -439602,19 +130716,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -439630,12 +130744,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5742741\n"); + $fwrite(fp,"5600933\n"); end - xrf = 64'hEF54D77132AC7CCD; - y = 64'hC1FFFFFFFFFDBFFF; - zrf = 64'hC09FFFFFFFFFFDDF; - ans = 64'h7164D77132AB05A6; + x = 64'hBDCE895D0278844A; + y = 64'h401FFFFFFFFFFFFF; + z = 64'h3810DF2445F89E39; + ans = 64'hBDFE895D02788449; rn = 1; rz = 0; rm = 0; @@ -439649,19 +130763,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -439677,12 +130791,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5743355\n"); + $fwrite(fp,"5602947\n"); end - xrf = 64'hBF8000000000BFFF; - y = 64'h4000000000000000; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFE08000000005FF; + x = 64'h3F98000000000800; + y = 64'h401FFFFFFFEFFEFE; + z = 64'hB7EFFFFE7FFFFFFF; + ans = 64'h3FC7FFFFFFF4073E; rn = 1; rz = 0; rm = 0; @@ -439696,19 +130810,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -439724,105 +130838,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5743969\n"); + $fwrite(fp,"5604961\n"); end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h802FFFFFEFDFFFFF; - zrf = 64'hC01FFFFFFF00007F; - ans = 64'h401FFFFFE0BFFF7D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5744583\n"); - end - xrf = 64'hC00FFFFFFFFFDFFA; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hB80E75A4E015E18C; - ans = 64'hC02FFFFFFFFFDFF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5745197\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h08C00100000000FF; - zrf = 64'hFFFFFFFFFFFFFFFE; + x = 64'hFFE0000000000000; + y = 64'h434FFFFFFFFFFFFE; + z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -439837,19 +130857,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -439865,670 +130885,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5745811\n"); + $fwrite(fp,"5606975\n"); end - xrf = 64'h430F800000000007; - y = 64'h43C1F90528A18427; - zrf = 64'hC0B000000008000F; - ans = 64'h46E1B12113FEFE1A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5746425\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h4010000000000000; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5747039\n"); - end - xrf = 64'hC347FFFEFFFFFFFF; - y = 64'hC060474967F42DF4; - zrf = 64'h4010000000000000; - ans = 64'h43B86AED1779AE6E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5747653\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'h41FFFC0080000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5748267\n"); - end - xrf = 64'hC00FFFFFFFFFF77E; - y = 64'h434C33324EEE4B94; - zrf = 64'h41CFFFEFFEFFFFFF; - ans = 64'hC36C333246EE4815; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5748881\n"); - end - xrf = 64'h480FDCF4B7D66D3E; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hBFD0000000000000; - ans = 64'h483FDCF4B7D66D3C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5749495\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h3FC182D75584B1E3; - zrf = 64'h41E000003FFFC000; - ans = 64'hFFC182D75584B1E2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5750109\n"); - end - xrf = 64'h43FFF80000000001; - y = 64'h4340000000000001; - zrf = 64'hC3C03FFFFFFBFFFE; - ans = 64'h474FF80000000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5750723\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'hC1FF800000007FFF; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5751337\n"); - end - xrf = 64'h402FFE00001FFFFF; - y = 64'h43D55C72A75BD423; - zrf = 64'hC0100007FF000000; - ans = 64'h44155B1CE046BAD8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5751951\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h8000000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5752565\n"); - end - xrf = 64'hC3EFFFFFFDFFFF00; - y = 64'hBFCFFFBFFFEFFFFE; - zrf = 64'h4000000000000001; - ans = 64'h43CFFFBFFDF002FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5753179\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h7FE0000000000001; - zrf = 64'hBED0000000000240; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5753793\n"); - end - xrf = 64'h3F2000000FF7FFFF; - y = 64'hF0B00200003FFFFF; - zrf = 64'hC0A000000400000E; - ans = 64'hEFE002001039FEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5754407\n"); - end - xrf = 64'h381F1F6C8582CCAD; + x = 64'h3CA00000005FFFFF; y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hBCA0000000000001; - ans = 64'h781F1F6C8582CCAC; + z = 64'h7FE0043FFFFFFFFF; + ans = 64'h7FE0044000000000; rn = 1; rz = 0; rm = 0; @@ -440542,19 +130904,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -440570,12 +130932,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5755021\n"); + $fwrite(fp,"5608989\n"); end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h377FFFFF8007FFFE; - zrf = 64'hBFE008000003FFFF; - ans = 64'hF77FFFFF8007FFFD; + x = 64'hBE10000000080010; + y = 64'h41E00000003FFBFF; + z = 64'h3EA954E801D58ACC; + ans = 64'hBFFFFFFF35E8B80F; rn = 1; rz = 0; rm = 0; @@ -440589,19 +130951,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -440617,12 +130979,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5755635\n"); + $fwrite(fp,"5611003\n"); end - xrf = 64'h3D80200080000000; - y = 64'h7FF0000000000000; - zrf = 64'h40307FF7FFFFFFFE; - ans = 64'h7FF0000000000000; + x = 64'hFFE0000000000000; + y = 64'h7FFFFFFFFFFFFFFE; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -440636,19 +130998,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -440664,12 +131026,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5756249\n"); + $fwrite(fp,"5613017\n"); end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'hC01B9B1F9E5D3B06; - zrf = 64'hFFE0000000000001; - ans = 64'h7FF0000000000000; + x = 64'hBD200003FFF7FFFE; + y = 64'h800FFFFFFFFFFFFF; + z = 64'h3F3BFFFFFFFFFFEE; + ans = 64'h3F3BFFFFFFFFFFEE; rn = 1; rz = 0; rm = 0; @@ -440683,19 +131045,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -440711,12 +131073,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5756863\n"); + $fwrite(fp,"5615031\n"); end - xrf = 64'h001AD019E1F198C4; - y = 64'h362FFFFFFFFE03FE; - zrf = 64'hC0076F3D0779ED74; - ans = 64'hC0076F3D0779ED74; + x = 64'hB70FFFFFEFFFFF7F; + y = 64'hC03C206056154C17; + z = 64'h3E007E0000000000; + ans = 64'h3E007E0000000000; rn = 1; rz = 0; rm = 0; @@ -440730,19 +131092,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -440758,12 +131120,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5757477\n"); + $fwrite(fp,"5617045\n"); end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h7FF0000000000001; - ans = 64'h7FFFFFFFFFFFFFFF; + x = 64'hFFE0000000000000; + y = 64'h801FFFFFFFFFFFFE; + z = 64'h3FF0000000000001; + ans = 64'h4013FFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -440777,19 +131139,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -440805,12 +131167,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5758091\n"); + $fwrite(fp,"5619059\n"); end - xrf = 64'h39800008FFFFFFFF; - y = 64'hC1CEFFC0608184C1; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'h3FFFFFFFFFFFFFFF; + x = 64'h40300000000000FF; + y = 64'hBCA0000000000001; + z = 64'hC05FFFFFF7FFFFEE; + ans = 64'hC05FFFFFF7FFFFEE; rn = 1; rz = 0; rm = 0; @@ -440824,19 +131186,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -440852,12 +131214,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5758705\n"); + $fwrite(fp,"5621073\n"); end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h8000000000000000; - zrf = 64'h37FFFFFFFF7EFFFE; - ans = 64'h37FFFFFFFF7EFFFE; + x = 64'h404FFFFFFFFDFFF7; + y = 64'h381FFFFFDFFFFFE0; + z = 64'hC1C00FFFFFFFFBFF; + ans = 64'hC1C00FFFFFFFFBFF; rn = 1; rz = 0; rm = 0; @@ -440871,19 +131233,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -440899,716 +131261,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5759319\n"); + $fwrite(fp,"5623087\n"); end - xrf = 64'hBFCFFFC000800000; - y = 64'hBFB0000008000FFE; - zrf = 64'h3FD0080000000001; - ans = 64'h3FD107FE00840001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5759933\n"); - end - xrf = 64'h43F4595959DECE4B; - y = 64'h8000000000000001; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h80D45B5959DECE4B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5760547\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h41DFFFFDFBFFFFFF; - zrf = 64'hBF9000000000010E; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5761161\n"); - end - xrf = 64'hBFEB3A4E4909E271; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h3800000003FFFFFE; - ans = 64'h3800000003FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5761775\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h4035B7D4B985B276; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5762389\n"); - end - xrf = 64'hBFDA4D1C0A3F275B; - y = 64'hC27FFFFF7FFFC000; - zrf = 64'hBF200007EFFFFFFE; - ans = 64'h426A4D1BA10A8297; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5763003\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h8010000000000001; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5763617\n"); - end - xrf = 64'h4DCFFFFFFFFF7F7F; - y = 64'hC5EFFBFFF0000000; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'hD3CFFBFFEFFF7F8F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5764231\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'hA07FFBFFFFFF0000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5764845\n"); - end - xrf = 64'h37FA1C4C477FCDAA; - y = 64'h0000000000007DFF; - zrf = 64'hB7E94EA427DCCB05; - ans = 64'hB7E94EA427DCCB05; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5765459\n"); - end - xrf = 64'h7F801007FFFFFFFF; - y = 64'hBCA0000000000000; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'hFC301007FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5766073\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'hC020DB9C31C891F2; - zrf = 64'hD8C0003FFFE00000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5766687\n"); - end - xrf = 64'h3FD03FFFFFFFFFFB; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'hFFFFFFF8000FFFFE; - ans = 64'hFFFFFFF8000FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5767301\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'hB89FDFFFFFFFDFFE; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'h789FDFFFFFFFDFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5767915\n"); - end - xrf = 64'hC11FFC0000000003; - y = 64'h7CF0000400000000; - zrf = 64'h38000000000101FE; - ans = 64'hFE1FFC07FF000003; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5768529\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'hBFD0000000000000; - zrf = 64'h434FFFFFFFFFFFFE; + x = 64'hFFE0000000000000; + y = 64'hBFDFFFFFFFFFFFFF; + z = 64'hC340000000000000; ans = 64'h7FCFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -441623,19 +131280,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -441651,247 +131308,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5769143\n"); + $fwrite(fp,"5625101\n"); end - xrf = 64'h3FCFFF0000000006; - y = 64'h802C66EC85223038; - zrf = 64'h3FE0000000000000; - ans = 64'h3FE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5769757\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'hBFD0000000000001; - zrf = 64'hC05007FE00000000; - ans = 64'h7FD0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5770371\n"); - end - xrf = 64'hBF703FFFFFFFBFFF; - y = 64'h3FB001F000000000; - zrf = 64'h3FEF00000000FFFF; - ans = 64'h3FEEFDF7C1090007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5770985\n"); - end - xrf = 64'h407000FFFC000000; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h8000000000000000; - ans = 64'hC06000FFFBFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5771599\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h3FDE0222D3F0060A; - zrf = 64'h56E02C049AF176F4; - ans = 64'hFFDE0222D3F00609; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5772213\n"); - end - xrf = 64'hC1E9ABEA9C873D0C; + x = 64'h00D10000FFFFFFFE; y = 64'hBFE0000000000001; - zrf = 64'hBF185AE5E20A7317; - ans = 64'h41D9ABEA9C873B88; + z = 64'h400FF801FFFFFFFF; + ans = 64'h400FF801FFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -441905,19 +131327,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -441933,12 +131355,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5772827\n"); + $fwrite(fp,"5627115\n"); end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h6A268B9232F55FBA; - zrf = 64'hC010000000000000; - ans = 64'hFFF0000000000000; + x = 64'h3F8FFFDFFFFFF7FF; + y = 64'hBFDFFFE0000FFFFE; + z = 64'hBFC00000002007FF; + ans = 64'hBFC0FFFE002187BE; rn = 1; rz = 0; rm = 0; @@ -441952,19 +131374,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -441980,9552 +131402,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5773441\n"); + $fwrite(fp,"5629129\n"); end - xrf = 64'hC00000000020007F; - y = 64'hB7EFFFFC00007FFE; - zrf = 64'h47CF720912535C10; - ans = 64'h47CF720912535C10; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5774055\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'h4340000000000000; - ans = 64'h7FEFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5774669\n"); - end - xrf = 64'h80100000080001FF; - y = 64'h43F0080000000001; - zrf = 64'h3FD0000000000001; - ans = 64'h3FD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5775283\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'hBFF0000000000000; - zrf = 64'h403FFFFFF83FFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5775897\n"); - end - xrf = 64'h7A9FC003FFFFFFFF; - y = 64'h3C6FF7F000000000; - zrf = 64'hC03EC69744BF0F32; - ans = 64'h771FB8041EFDFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5776511\n"); - end - xrf = 64'h43C8000FFFFFFFFE; + x = 64'hFFE0000000000000; y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5777125\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'hC7F0000003FE0000; - zrf = 64'hC1E2FFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5777739\n"); - end - xrf = 64'h3FD2AACB10678B3A; - y = 64'hC000000000000000; - zrf = 64'h3FC020000FFFFFFE; - ans = 64'hBFDD459618CF1675; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5778353\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h37FFFFFFFFFFFFED; - zrf = 64'hC000000000000001; - ans = 64'hF7FFFFFFFFFFFFEC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5778967\n"); - end - xrf = 64'hBFD0000000008100; - y = 64'h7FF07FFFBFFFFFFF; - zrf = 64'hBE007FFDFFFFFFFF; - ans = 64'h7FF87FFFBFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5779581\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h4010000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5780195\n"); - end - xrf = 64'hBD4FBFFFFFFFFFEE; - y = 64'hFFEFFFFFFF000020; - zrf = 64'h3CAFFFFFFFFFFFFF; - ans = 64'h7D4FBFFFFF02000E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5780809\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h3EB1ACFBC7DEEDCA; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5781423\n"); - end - xrf = 64'hC3D000400000000F; - y = 64'h3FF0000000080100; - zrf = 64'h4050D98EFB47EDA9; - ans = 64'hC3D000400008012F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5782037\n"); - end - xrf = 64'h3FFFFFDFFFBFFFFF; - y = 64'hC010000000000001; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5782651\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h3CA14E19E3A06F13; - zrf = 64'h7FE00000000FF7FE; - ans = 64'h7FE00000000FF7FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5783265\n"); - end - xrf = 64'h3FDFFFFFC0008000; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h3FA000007FF7FFFF; - ans = 64'hC00FBFFFBE009FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5783879\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h8430010007FFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'h4430010007FFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5784493\n"); - end - xrf = 64'h380857E926314C99; - y = 64'h3FFFDFFFF7FFFFFE; - zrf = 64'hC7E0000008000100; - ans = 64'hC7E0000008000100; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5785107\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'hC340000000000001; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5785721\n"); - end - xrf = 64'h001CEC565E745A24; - y = 64'h47EFFF7FFFFBFFFE; - zrf = 64'h001FFFFFFFFFFFFE; - ans = 64'h081CEBE2AD1742C6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5786335\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'hBF900004FFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5786949\n"); - end - xrf = 64'h3FE0000010FFFFFF; - y = 64'h3FD00003FFFF0000; - zrf = 64'h41FFFFFFFC00000E; - ans = 64'h41FFFFFFFC02000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5787563\n"); - end - xrf = 64'h3FDFDE10DEDCA726; - y = 64'hFFE0000000000000; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'hFFCFDE10DEDCA726; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5788177\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'h40CFFFFFFFBFFFEF; - zrf = 64'h480003FFFFFFEFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5788791\n"); - end - xrf = 64'h3FEFFFFFFFFFFF00; - y = 64'hFFE0000000000001; - zrf = 64'hBCD0000003FFFEFF; - ans = 64'hFFDFFFFFFFFFFF02; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5789405\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'hC298162BB741A352; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5790019\n"); - end - xrf = 64'h381000000000021F; - y = 64'hB80E49E5E0E03599; - zrf = 64'h7FE8000007FFFFFF; - ans = 64'h7FE8000007FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5790633\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'hFFF0000000000000; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5791247\n"); - end - xrf = 64'hC30001FFFFFFFFDE; - y = 64'h3FEC6E5AABA5D69A; - zrf = 64'h0010000000000000; - ans = 64'hC2FC71E876FB4B18; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5791861\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFF; - y = 64'hFFF0000000000001; - zrf = 64'h43DFFFFE03FFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5792475\n"); - end - xrf = 64'hC03000027FFFFFFF; - y = 64'hC041A9C563D0F126; - zrf = 64'hA800000000008400; - ans = 64'h4081A9C82657C8BE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5793089\n"); - end - xrf = 64'h236FFFFFC0000000; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'h4340000000000000; - ans = 64'hFFFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5793703\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hC59FF00080000000; - zrf = 64'hBCB000200000001E; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5794317\n"); - end - xrf = 64'h403F7FFFFFFFFFFF; - y = 64'h0000000000000000; - zrf = 64'hC3F000000020003F; - ans = 64'hC3F000000020003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5794931\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h3504386F2FD6474A; - zrf = 64'hBFE0000000000000; - ans = 64'hF504386F2FD64749; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5795545\n"); - end - xrf = 64'h38015227B535355A; - y = 64'h40C000000010007E; - zrf = 64'h4010003FFFDFFFFF; - ans = 64'h4010003FFFDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5796159\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'h3FF0000000000000; - ans = 64'hC007FFFFFFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5796773\n"); - end - xrf = 64'hB7E00000008FFFFF; - y = 64'h37BFF80000200000; - zrf = 64'h0000000000000001; - ans = 64'hAFAFF800013FB7FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5797387\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h0010000000000000; - zrf = 64'hC8074FAE3612EF34; - ans = 64'hC8074FAE3612EF34; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5798001\n"); - end - xrf = 64'h3D700000037FFFFF; - y = 64'hB7E0100000000020; - zrf = 64'h7FE661A3FA55045D; - ans = 64'h7FE661A3FA55045D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5798615\n"); - end - xrf = 64'hC3E001FFFFFFFFFE; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'h4010000000000001; - ans = 64'h4010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5799229\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hC12FFF8000000FFF; - zrf = 64'h35E6B949DB71601D; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5799843\n"); - end - xrf = 64'hB7E0000002000010; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h8000000DFFFFFFFE; - ans = 64'h8000000DFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5800457\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hBFE000080007FFFE; - zrf = 64'hBFD0000000000001; - ans = 64'h7FE000080007FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5801071\n"); - end - xrf = 64'h0010000000004080; - y = 64'h43FC00000000007F; - zrf = 64'hC020000040FFFFFF; - ans = 64'hC020000040FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5801685\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h3FE0000000000001; - ans = 64'hFCAFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5802299\n"); - end - xrf = 64'hC7F010003FFFFFFF; - y = 64'h3FEC000001FFFFFF; - zrf = 64'hFFFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5802913\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h36F0001FFFFBFFFE; - ans = 64'hFCAFFFFFFFFFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5803527\n"); - end - xrf = 64'hBF70FFFFFFF00000; - y = 64'hC2D00000403FFFFF; - zrf = 64'hBF9FFF800FFFFFFE; - ans = 64'h425100004433FDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5804141\n"); - end - xrf = 64'hC3E0000001FFFF7F; - y = 64'h3FD0000000000001; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'hC3C0000001FFFF80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5804755\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hA5100000FFEFFFFF; - zrf = 64'h3FE0E00000000000; - ans = 64'h65100000FFEFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5805369\n"); - end - xrf = 64'h000FFFFFFFC00000; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'hC013FEEE8B19D89A; - ans = 64'hC013FEEE8B19D89A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5805983\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hC3EFFF0007FFFFFF; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5806597\n"); - end - xrf = 64'hBFBFFFFFFFF3FFFF; - y = 64'hC1D03FFFFFFFFFFB; - zrf = 64'h43E0201FFFFFFFFF; - ans = 64'h43E02020000103FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5807211\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h3FE0000000000001; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5807825\n"); - end - xrf = 64'hC3D541D43572E6E5; - y = 64'h43FFFFFFAFFFFFFF; - zrf = 64'hFFEFFFFFFFFFFFFE; - ans = 64'hFFEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5808439\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'hB91A0602CC041CF8; - ans = 64'hFFEFFFFFFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5809053\n"); - end - xrf = 64'hC3DC617D85DF8CC0; - y = 64'h41F0003FFFFFFFBF; - zrf = 64'h5D5FFFFFFFFFFC00; - ans = 64'h5D5FFFFFFFFFFC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5809667\n"); - end - xrf = 64'hC00000000000041F; - y = 64'h3FF0000000000000; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'hBD60800000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5810281\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h5ACFFFDFFFFF7FFF; - zrf = 64'hBFD0000010000010; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5810895\n"); - end - xrf = 64'hBFEFFFFF9FFFFFFF; - y = 64'h3FF0000000000001; - zrf = 64'h3DEB9C7A0EA351CE; - ans = 64'hBFEFFFFF9FE46387; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5811509\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h40295931DEF76D4E; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5812123\n"); - end - xrf = 64'h3CAAC1DEBE35C214; - y = 64'h37F00007BFFFFFFF; - zrf = 64'h3ECFFF80000000FE; - ans = 64'h3ECFFF80000000FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5812737\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h4000000000000000; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5813351\n"); - end - xrf = 64'hC17003FFF0000000; - y = 64'hC1C5CBAC931F6C9C; - zrf = 64'hFFE0000000000000; - ans = 64'hFFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5813965\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h4000000000000001; - zrf = 64'hBFF83CD6D194ABCC; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5814579\n"); - end - xrf = 64'hC0100000000A0000; - y = 64'h3DD000000000083F; - zrf = 64'hC80000000000DFFF; - ans = 64'hC80000000000DFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5815193\n"); - end - xrf = 64'h40481EDD295E2454; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'h3FF0000000000000; - ans = 64'h40683EDD295E2452; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5815807\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hB9AFFFFFFFFF0007; - zrf = 64'hFFFFFFFFFFFFDFFF; - ans = 64'hFFFFFFFFFFFFDFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5816421\n"); - end - xrf = 64'hC06000000080003F; - y = 64'h4010000000000000; - zrf = 64'hBA9000000000C000; - ans = 64'hC08000000080003F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5817035\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h21100001000007FF; - zrf = 64'h8010000000000000; - ans = 64'hE1100001000007FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5817649\n"); - end - xrf = 64'h43C0000014000000; - y = 64'hC34FBFFFFFFEFFFF; - zrf = 64'hB9686781F8451DDC; - ans = 64'hC71FC00027AEFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5818263\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h3CA0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5818877\n"); - end - xrf = 64'h7E0E385A973D847B; - y = 64'hC6100000001007FE; - zrf = 64'hC340000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5819491\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h4340000000000000; - zrf = 64'hB8F83B1006ECD4DB; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5820105\n"); - end - xrf = 64'h00100000000000DE; - y = 64'h3D5FFFEFF0000000; - zrf = 64'h41F000000000001F; - ans = 64'h41F000000000001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5820719\n"); - end - xrf = 64'hFFE9A80F1A846CA8; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'h3FE0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5821333\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hB7EFFFFFFC040000; - zrf = 64'hC3C1020000000000; - ans = 64'h77EFFFFFFC03FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5821947\n"); - end - xrf = 64'hC1BFFFFFEFFFFFFC; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'hB964C595383F9BD7; - ans = 64'hC51FFFFFEFFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5822561\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h3DCFFFFFFC07FFFE; - zrf = 64'h8000000000000001; - ans = 64'hFDCFFFFFFC07FFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5823175\n"); - end - xrf = 64'hC6FFF87FFFFFFFFE; - y = 64'h80045FD0E1E67499; - zrf = 64'h5806ABE374FD09BD; - ans = 64'h5806ABE374FD09BD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5823789\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'h0010000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5824403\n"); - end - xrf = 64'hC1D000FFFFFFE000; - y = 64'hC00000003FFFFEFF; - zrf = 64'hC01FFFFFFFFFFFFF; - ans = 64'h41E001003F03DEFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5825017\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h37EBFFFFFFFFFFBE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5825631\n"); - end - xrf = 64'h002FFFFF81000000; - y = 64'h380F7FFF7FFFFFFF; - zrf = 64'h3FAFFFFFFFB7FFFE; - ans = 64'h3FAFFFFFFFB7FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5826245\n"); - end - xrf = 64'h41E000000800007F; - y = 64'h7FF0000000000001; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5826859\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h47F0000800001000; - zrf = 64'hB810008000000002; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5827473\n"); - end - xrf = 64'hC7E3993575A37EB5; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'hC35FFFFF80200000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5828087\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h38F378198B20E370; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5828701\n"); - end - xrf = 64'hC1F09FFFFFFFFFFF; - y = 64'h3FEEFFFFFFFFEFFE; - zrf = 64'h4038DD655BA39610; - ans = 64'hC1F01AFFFE722158; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5829315\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h8000000000000001; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h3CCFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5829929\n"); - end - xrf = 64'h402E64AF0C8923D5; - y = 64'hB7E9C260B56BD0E4; - zrf = 64'hC00FFFFFFFFFFFFE; - ans = 64'hC00FFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5830543\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h3FDB7DD41030A248; - ans = 64'h4011B7DD41030A23; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5831157\n"); - end - xrf = 64'h801EEFFFFFFFFFFF; - y = 64'hC3F48EC0870B3955; - zrf = 64'hC3EFFFDFFFDFFFFF; - ans = 64'hC3EFFFDFFFDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5831771\n"); - end - xrf = 64'h41C685B978340276; - y = 64'h8010000000000000; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h3CAFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5832385\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h800001FFFBFFFFFF; - zrf = 64'hBAC0000FFEFFFFFF; - ans = 64'h3F5FFFBFFFFFEFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5832999\n"); - end - xrf = 64'h80000000400000FF; - y = 64'h8010000000000001; - zrf = 64'h7FF7592910D8B634; - ans = 64'h7FFF592910D8B634; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5833613\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h434FFC0000000040; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5834227\n"); - end - xrf = 64'hC02FFFFFC0200000; - y = 64'hA670004000000FFF; - zrf = 64'hBE496B26FBEFF881; - ans = 64'hBE496B26FBEFF881; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5834841\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h801FFFFFFFFFFFFE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5835455\n"); - end - xrf = 64'h462E002D0A1D6978; - y = 64'hBFC000000000801E; - zrf = 64'hC000000000000000; - ans = 64'hC5FE002D0A1E59B2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5836069\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hBCA0000000000001; - zrf = 64'h47EFFFFE000001FF; - ans = 64'h7CA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5836683\n"); - end - xrf = 64'hC7E164B94F90E483; - y = 64'h3FE00000001003FE; - zrf = 64'h48000800000003FF; - ans = 64'h47FBB6D1AC177499; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5837297\n"); - end - xrf = 64'h38CC7BD0BC05E161; - y = 64'hBCAFFFFFFFFFFFFE; - zrf = 64'h3CA0000000000000; - ans = 64'h3CA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5837911\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hC030000000003FF0; - zrf = 64'h402FFFFC00000002; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5838525\n"); - end - xrf = 64'h001FFFFFFEFFFFFE; - y = 64'hBFD0000000000000; - zrf = 64'h43CFFFE7FFFFFFFF; - ans = 64'h43CFFFE7FFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5839139\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hCFF002007FFFFFFF; - zrf = 64'h7FE0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5839753\n"); - end - xrf = 64'hC06E77834B9A2F3A; - y = 64'h80045DE73BDB8F9D; - zrf = 64'h4000001FFFFFFFFF; - ans = 64'h4000001FFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5840367\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5840981\n"); - end - xrf = 64'hBCA0000004000080; - y = 64'hBFF0000000000009; - zrf = 64'hBFF0000000000001; - ans = 64'hBFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5841595\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hBFE0000000000000; - zrf = 64'h3FDF73C27AEDD604; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5842209\n"); - end - xrf = 64'h449FE1FFFFFFFFFF; - y = 64'hC02DEFFFFFFFFFFE; - zrf = 64'hC010001F80000000; - ans = 64'hC4DDD3EEFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5842823\n"); - end - xrf = 64'hC6EFFF001FFFFFFE; - y = 64'hBFEFFFFFFFFFFFFF; - zrf = 64'h0010000000000001; - ans = 64'h46EFFF001FFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5843437\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h002FEFDFFFFFFFFE; - zrf = 64'h43400001FFFFFE00; - ans = 64'h43400001FFFFFDF8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5844051\n"); - end - xrf = 64'hC34F000007FFFFFF; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hC1C0000000000090; - ans = 64'h434EFFFFF7FFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5844665\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h3FD007FF80000000; - zrf = 64'h4340000000000001; - ans = 64'hFFD007FF7FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5845279\n"); - end - xrf = 64'hC1DFDBFFFFFFFFFF; - y = 64'h3F60020003FFFFFF; - zrf = 64'h4AC0000001EFFFFF; - ans = 64'h4AC0000001EFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5845893\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hBFF0000000000001; - zrf = 64'hFFE0000000000001; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5846507\n"); - end - xrf = 64'h8700300000000000; - y = 64'h3FEFAE090E99FE5C; - zrf = 64'hBFEFFFFFFFFFFFFF; - ans = 64'hBFEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5847121\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'hBCAB13B8622D0CCE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5847735\n"); - end - xrf = 64'hE62FFFFF800001FE; - y = 64'h7FDFFFFFFFFFBF00; - zrf = 64'h41600000FFFFFFF0; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5848349\n"); - end - xrf = 64'hBFDFFFFFFFFFBFFD; - y = 64'hC000000000000001; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'h3FEFFFFFFFFFBFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5848963\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h046FFFFFFFFDF7FF; - zrf = 64'h001000040000003E; - ans = 64'hC46FFFFFFFFDF7FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5849577\n"); - end - xrf = 64'h41D007FFFDFFFFFE; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h3FF0000007FFF7FF; - ans = 64'hC1F007FFFDEFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5850191\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hBCAFFFFF7BFFFFFF; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'h7CAFFFFF7BFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5850805\n"); - end - xrf = 64'h43FFFFF00000003F; - y = 64'h47F007FFFFFFFFBF; - zrf = 64'h41D00000FF7FFFFE; - ans = 64'h4C0007F7FBFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5851419\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hC010000000000000; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5852033\n"); - end - xrf = 64'h32F0000000003FF8; - y = 64'h8D70000002004000; - zrf = 64'hBFDFFFFFFFFFFFFE; - ans = 64'hBFDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5852647\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'hBB9FDFEFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5853261\n"); - end - xrf = 64'h002FFFFFFFF00004; - y = 64'h47FA9307B5F217D1; - zrf = 64'h7FF0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5853875\n"); - end - xrf = 64'h8010207FFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5854489\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h7FD000FFFFFFFFE0; - zrf = 64'h37E0080000800000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5855103\n"); - end - xrf = 64'h3F03F709373A04B9; - y = 64'hC340000000000001; - zrf = 64'h47ED270DC25392FC; - ans = 64'h47ED270DC25392FC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5855717\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h541F6EDD19719706; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5856331\n"); - end - xrf = 64'h29AFFFFF00000003; - y = 64'hC47FF00001FFFFFF; - zrf = 64'hC02153107AFE4A2A; - ans = 64'hC02153107AFE4A2A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5856945\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5857559\n"); - end - xrf = 64'hC1E5937AC0575FBB; - y = 64'hC29FFFFFFF7DFFFE; - zrf = 64'hBFD0000000000000; - ans = 64'h4495937ABFFFB897; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5858173\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hFFE0000000000001; - zrf = 64'hB7E000000200000E; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5858787\n"); - end - xrf = 64'h43E2BF851EBE18BF; - y = 64'hC02FFFFFFFBFFFFE; - zrf = 64'h471FFDFFFFFF7FFF; - ans = 64'h471FFDFFFFFF7FDA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5859401\n"); - end - xrf = 64'h3FBFFFFFFFB80000; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5860015\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hC03FFBFFFFFFF000; - zrf = 64'h3FD000FFFEFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5860629\n"); - end - xrf = 64'hC010000FFFFFF800; - y = 64'hFFF0000000000000; - zrf = 64'h47FCE83171B3D9A4; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5861243\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h46C657D018C4D2F1; - zrf = 64'h4000000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5861857\n"); - end - xrf = 64'h37E0FFEFFFFFFFFF; - y = 64'hC03FFFFE1FFFFFFF; - zrf = 64'h3FFFFFFFFFFDF7FF; - ans = 64'h3FFFFFFFFFFDF7FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5862471\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hC010000000000000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5863085\n"); - end - xrf = 64'h8006A5A88898E419; - y = 64'h402005FFFFFFFFFE; - zrf = 64'hBCA0000000000001; - ans = 64'hBCA0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5863699\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h0000000000000000; - zrf = 64'h41CD76D5CFA75711; - ans = 64'hFFF8000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5864313\n"); - end - xrf = 64'h41CE000000020000; - y = 64'hC02FFFFFFFFFF5FF; - zrf = 64'h3C000000000007FE; - ans = 64'hC20E00000001F69F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5864927\n"); - end - xrf = 64'h432221F695365DBA; - y = 64'h0000000000000001; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5865541\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h418000000103FFFF; - zrf = 64'hC1C4268A8DE92F15; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5866155\n"); - end - xrf = 64'h43EFFF8001FFFFFE; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hC188C0C8C078AF80; - ans = 64'hC188C0C8C078AF80; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5866769\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hD44DA91B879E1FAE; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5867383\n"); - end - xrf = 64'hB80F80000000003F; - y = 64'hC03FFFE7FFFFFFFE; - zrf = 64'hC1E001FFFEFFFFFF; - ans = 64'hC1E001FFFEFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5867997\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h0010000000000001; - zrf = 64'hC000000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5868611\n"); - end - xrf = 64'h338001FFF7FFFFFF; - y = 64'h7FD34D53E2CFA357; - zrf = 64'h801FFFFFFFFFFFFF; - ans = 64'h73634FBD83A55359; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5869225\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'hE5C000007FFFFBFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5869839\n"); - end - xrf = 64'hBF4FFFFFFFFFFFFF; - y = 64'hBFC00004000007FE; - zrf = 64'h10300000001DFFFE; - ans = 64'h3F200004000007FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5870453\n"); - end - xrf = 64'hFFFFFFFFFE03FFFE; - y = 64'h3CA0000000000000; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFE03FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5871067\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hFFEFF80000000400; - zrf = 64'hC014040000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5871681\n"); - end - xrf = 64'hBFD0000000200001; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'h41D000003FDFFFFF; - ans = 64'h41D000003FDFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5872295\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hFFD005FFFFFFFFFE; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5872909\n"); - end - xrf = 64'hDCB0010FFFFFFFFF; - y = 64'hC0B0000FEFFFFFFF; - zrf = 64'hBD1FBFFFFDFFFFFE; - ans = 64'h5D70011FF10EEFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5873523\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h3FD0000000000000; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5874137\n"); - end - xrf = 64'h380DF551097EEC8C; - y = 64'h3803158CF527D8E6; - zrf = 64'h800FFFFFFFFFFFFE; - ans = 64'h3021DDD51197A3C4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5874751\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h801FFFFFFFFEF7FF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5875365\n"); - end - xrf = 64'hC3E92CBED20ADAF7; - y = 64'hC3EFFE00007FFFFF; - zrf = 64'h0A29B37D158B721E; - ans = 64'h47E92B2C06826D44; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5875979\n"); - end - xrf = 64'h3FC7B88E7CD2F508; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'hC01FA11DC60CB42A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5876593\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hC00FF7FFFC000000; - zrf = 64'h3FF60FFBCA03EA48; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5877207\n"); - end - xrf = 64'h3FDFFFFF801FFFFE; - y = 64'h3FE0000000000001; - zrf = 64'hC001BFFFFFFFFFFE; - ans = 64'hBFFF80000FFBFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5877821\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h3E94A47BDFBBC5AE; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5878435\n"); - end - xrf = 64'hC76CB6AD83194617; - y = 64'hC80947067BC1EAD2; - zrf = 64'h8CA000FC00000000; - ans = 64'h4F86AE72B0B352D5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5879049\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5879663\n"); - end - xrf = 64'hC00C39E2AE0F86B2; - y = 64'h43F000010000FFFE; - zrf = 64'h8000000000000000; - ans = 64'hC40C39E471AF752E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5880277\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h3FF0000000000001; - zrf = 64'h02E0000203FFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5880891\n"); - end - xrf = 64'h400FF80000000002; - y = 64'h3FEFFFFBFFFFF000; - zrf = 64'hC004E55219DA87D8; - ans = 64'h3FF62553CE4AD05C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5881505\n"); - end - xrf = 64'hBF10060000000000; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hC010000000000000; - ans = 64'hC01000200C000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5882119\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h3E317BD068F8BEDF; - zrf = 64'h4030003FFFFF0000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5882733\n"); - end - xrf = 64'hBD80001FEFFFFFFE; - y = 64'h4000000000000000; - zrf = 64'h7FDFFFF8000001FF; - ans = 64'h7FDFFFF8000001FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5883347\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h802FFEFFFFF7FFFF; - zrf = 64'h3FD0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5883961\n"); - end - xrf = 64'h43F0000000003EFE; - y = 64'h4010007FFFFFFFE0; - zrf = 64'h80000001BFFFFFFF; - ans = 64'h4410008000003EE0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5884575\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hBFE0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5885189\n"); - end - xrf = 64'h3FEA43D8D2DD7552; - y = 64'hC000000010007FFE; - zrf = 64'h7FF0000000000001; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5885803\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h4010000000000000; - zrf = 64'hC6F6C25EAEB14C96; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5886417\n"); - end - xrf = 64'h3FFFFFFFFF9FFFFE; - y = 64'h800000000F7FFFFE; - zrf = 64'h800FFDFFBFFFFFFE; - ans = 64'h800FFDFFDEFFFFFA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5887031\n"); - end - xrf = 64'h3FF0000000400003; - y = 64'h4010000000000001; - zrf = 64'hC000000000000001; - ans = 64'h4000000000800007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5887645\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h3FCFFFFFFFFFFFF7; - zrf = 64'hC00885CABDDA2B17; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5888259\n"); - end - xrf = 64'hC75FFFFFBFDFFFFE; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'h3AE0008000000200; - ans = 64'hC78FFFFFBFDFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5888873\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hC05FC0000000003F; - zrf = 64'h3CA0000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5889487\n"); - end - xrf = 64'hC240000FFFFFF000; - y = 64'h3FFF7FFFFBFFFFFE; - zrf = 64'hC02000000000003D; - ans = 64'hC24F801F7C03DC7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5890101\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h4340000000000001; - zrf = 64'hBFD0000000000001; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5890715\n"); - end - xrf = 64'hBE5FFFC1FFFFFFFE; - y = 64'h43C4000000000006; - zrf = 64'h7FEFFFFFFFFFFFFF; - ans = 64'h7FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5891329\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h434FFFFFFFFFFFFE; - zrf = 64'h43D400FFFFFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5891943\n"); - end - xrf = 64'h4D5A0E35823F598F; - y = 64'h41CAA957A54B3F62; - zrf = 64'hC0BA60E621A445E9; - ans = 64'h4F35B56DE1A35A42; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5892557\n"); - end - xrf = 64'h7FFFFF0000000010; - y = 64'h7FE0000000000000; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'h7FFFFF0000000010; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5893171\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hC21AFFFFFFFFFFFE; - zrf = 64'h3FC000000002FFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5893785\n"); - end - xrf = 64'h402F8653DAE1506A; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hA4D000003FFF7FFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5894399\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h381438E437450BA1; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5895013\n"); - end - xrf = 64'hC0A0000FFEFFFFFF; - y = 64'hC808FD02B65CA4D8; - zrf = 64'hB7FFFF7FFFDFFFFF; - ans = 64'h48B8FD1BB1CF8B08; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5895627\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h7FF0000000000000; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5896241\n"); - end - xrf = 64'h7FEFFF8000001000; - y = 64'h4017AA80D41D20AB; - zrf = 64'h434FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5896855\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h7FFFFFFFFFFFFFFF; - zrf = 64'h3FE000FFFFFFFFDF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5897469\n"); - end - xrf = 64'hC501FFBFFFFFFFFF; - y = 64'hBFC000000000081F; - zrf = 64'h606F000007FFFFFF; - ans = 64'h606F000007FFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5898083\n"); - end - xrf = 64'h433C923CB3313808; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'hBFEFFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -451540,19 +131421,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -451568,11 +131449,105 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5898697\n"); + $fwrite(fp,"5631143\n"); end - xrf = 64'hFFF0000000000000; - y = 64'h84BFFFFDFFFFE000; - zrf = 64'h3F80007F00000000; + x = 64'h81E0000000FFF800; + y = 64'hC000000000000001; + z = 64'h7FD01FFDFFFFFFFF; + ans = 64'h7FD01FFDFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5633157\n"); + end + x = 64'hCA20000000000004; + y = 64'h434FFC00000003FE; + z = 64'h30CFFFFFFFFFEFFE; + ans = 64'hCD7FFC0000000406; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5635171\n"); + end + x = 64'hFFE0000000000000; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -451587,19 +131562,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -451615,12 +131590,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5899311\n"); + $fwrite(fp,"5637185\n"); end - xrf = 64'h41CCC32B421F1AC0; - y = 64'h8000000000000001; - zrf = 64'h802FFFFC0000001E; - ans = 64'h802FFFFC1CC32B60; + x = 64'hBFBFF5FFFFFFFFFF; + y = 64'hC340000000000000; + z = 64'h6E300000007FFBFF; + ans = 64'h6E300000007FFBFF; rn = 1; rz = 0; rm = 0; @@ -451634,19 +131609,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -451662,12 +131637,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5899925\n"); + $fwrite(fp,"5639199\n"); end - xrf = 64'hFFF0000000000000; - y = 64'h3F8FFFFFFFEFFFFB; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'hFFF0000000000000; + x = 64'hC4708007FFFFFFFF; + y = 64'hB7FFFFFC00004000; + z = 64'hBFFFFFFFFFFFFFF4; + ans = 64'hBFFFFFFFFFFFFFF4; rn = 1; rz = 0; rm = 0; @@ -451681,19 +131656,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -451709,58 +131684,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5900539\n"); + $fwrite(fp,"5641213\n"); end - xrf = 64'hC1E6A557C00045BE; - y = 64'h400FFFFFDFBFFFFF; - zrf = 64'h7FEFFFF000020000; - ans = 64'h7FEFFFF000020000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5901153\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'h801FFFFFFFFFFFFE; + x = 64'hFFE0000000000000; + y = 64'hFFE0000000000001; + z = 64'hBFF0000000000001; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -451775,19 +131703,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -451803,11 +131731,105 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5901767\n"); + $fwrite(fp,"5643227\n"); end - xrf = 64'hBF59ED025EEE3634; - y = 64'h332EFFFFFFFFFFFB; - zrf = 64'h4340000000000000; + x = 64'hB87FFFF000000002; + y = 64'hFFF0000000000000; + z = 64'h5B5FFFFFFFFFFFFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5645241\n"); + end + x = 64'hFFFFFFFFFFDFFFFB; + y = 64'hCF3FFFFE00000FFF; + z = 64'hBC64B36DB2BB47FA; + ans = 64'hFFFFFFFFFFDFFFFB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5647255\n"); + end + x = 64'hFFE0000000000001; + y = 64'h0000000000000001; + z = 64'h4340000000000000; ans = 64'h4340000000000000; rn = 1; rz = 0; @@ -451822,19 +131844,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -451850,12 +131872,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5902381\n"); + $fwrite(fp,"5649269\n"); end - xrf = 64'hFFF0000000000000; - y = 64'h8010000000000001; - zrf = 64'h4EC6783E1C7CE0F2; - ans = 64'h7FF0000000000000; + x = 64'hB0F04000000007FE; + y = 64'h000FFFFFFFFFFFFE; + z = 64'hBFE011E572E754E2; + ans = 64'hBFE011E572E754E2; rn = 1; rz = 0; rm = 0; @@ -451869,19 +131891,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -451897,12 +131919,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5902995\n"); + $fwrite(fp,"5651283\n"); end - xrf = 64'h440EB0108E5D7083; - y = 64'h3570000FEFFFFFFF; - zrf = 64'hBF0FFF8000000040; - ans = 64'hBF0FFF8000000040; + x = 64'hE2DF075DF41FF2E3; + y = 64'h3C140000000001FF; + z = 64'hC361FFFFFBFFFFFF; + ans = 64'hDF03649AB893F9BD; rn = 1; rz = 0; rm = 0; @@ -451916,19 +131938,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -451944,2220 +131966,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5903609\n"); + $fwrite(fp,"5653297\n"); end - xrf = 64'h310FFFFE3FFFFFFF; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'hBFE0000000000000; - ans = 64'hBFE0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5904223\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hC000004000040000; - zrf = 64'hBFCD0273983498FD; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5904837\n"); - end - xrf = 64'hB9D310889BE4F295; - y = 64'hBCA0000000000000; - zrf = 64'hC7F44402C95C9CA4; - ans = 64'hC7F44402C95C9CA4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5905451\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hBF23FFFFFFFFFFEF; - zrf = 64'h0000000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5906065\n"); - end - xrf = 64'h40EFFFFFFFDFF800; - y = 64'h403FFFFE00001000; - zrf = 64'h3FBFFE001FFFFFFE; - ans = 64'h413FFFFE1FDE0822; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5906679\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h8010000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5907293\n"); - end - xrf = 64'h802FFFB000000000; - y = 64'h4804586CA2CA0B9C; - zrf = 64'h4010000000000001; - ans = 64'h4010000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5907907\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hBFD0000000000000; - zrf = 64'h002FFEFFFFFFFFBE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5908521\n"); - end - xrf = 64'hBF0FFFFEFFFFBFFF; - y = 64'h3F9A9ADED087CCBB; - zrf = 64'hBFF0000000001FDE; - ans = 64'hBFF00001A9ADFF99; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5909135\n"); - end - xrf = 64'hB3407FFBFFFFFFFF; - y = 64'hBFD0000000000001; - zrf = 64'hBFD0000000000001; - ans = 64'hBFD0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5909749\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h3FC008001FFFFFFF; - zrf = 64'hB9A06FFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5910363\n"); - end - xrf = 64'hC47FFC000007FFFF; - y = 64'hBFDFFFFFFFFFFFFE; - zrf = 64'h4010001000000003; - ans = 64'h446FFC000007FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5910977\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h400FF001FFFFFFFF; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5911591\n"); - end - xrf = 64'hC1603FEFFFFFFFFE; - y = 64'hCABFFF0003FFFFFF; - zrf = 64'h2E60000003FF7FFF; - ans = 64'h4C303F6E0287FDFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5912205\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hBFE0000000000001; - zrf = 64'h8000000000000001; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5912819\n"); - end - xrf = 64'hBFB000000000FFF7; - y = 64'hC0EFBFFFDFFFFFFF; - zrf = 64'h400FFFFFFFFFFFFF; - ans = 64'h40AFC7FFE001FBED; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5913433\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hBFEFFFFFFFFFFFFE; - zrf = 64'hB7E0004000000002; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5914047\n"); - end - xrf = 64'h37E708336BED77CC; - y = 64'h38167F06D6BC20B5; - zrf = 64'h45FFFFFFDDFFFFFE; - ans = 64'h45FFFFFFDDFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5914661\n"); - end - xrf = 64'h7FF1BC796545ECC4; - y = 64'hBFF0000000000000; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h7FF9BC796545ECC4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5915275\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hFFF4000000007FFE; - zrf = 64'hC1D000002007FFFF; - ans = 64'hFFFC000000007FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5915889\n"); - end - xrf = 64'hC03FFFFFFFFFFF80; - y = 64'hBFFFFFFFFFFFFFFF; - zrf = 64'h8FAFBFFDFFFFFFFE; - ans = 64'h404FFFFFFFFFFF7F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5916503\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hC3F00080000007FE; - zrf = 64'hFFEFFFFFFFFFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5917117\n"); - end - xrf = 64'hC0201000000000FF; - y = 64'hD67020FFFFFFFFFE; - zrf = 64'hBD00002000000080; - ans = 64'h56A03121000000FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5917731\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hC000000000000000; - zrf = 64'h7FFFFFFFFFFFFFFF; - ans = 64'h7FFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5918345\n"); - end - xrf = 64'hBE60001000000004; - y = 64'h405FFFFFF7FFFFFF; - zrf = 64'h3FFFFFFFFFFFFFFE; - ans = 64'h3FFFFFFBFFFC00FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5918959\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hC00FFFFFFFFFFFFF; - zrf = 64'h4058B8464E74C946; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5919573\n"); - end - xrf = 64'hB9D003FFFFFFFEFF; - y = 64'hC07FEFFFFFFFFFBF; - zrf = 64'h3CA000000FFF0000; - ans = 64'h3CA000000FFFFFC0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5920187\n"); - end - xrf = 64'h3CA63FE245CAF03F; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'hBCC63FE245CAF03E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5920801\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hE00003FEFFFFFFFF; - zrf = 64'h41E000000020007F; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5921415\n"); - end - xrf = 64'hF9D4000000000006; - y = 64'hC010000000000001; - zrf = 64'hBEA1FBFFFFFFFFFF; - ans = 64'h79F4000000000007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5922029\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hBF6000000000BFFE; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5922643\n"); - end - xrf = 64'hCDC000000C000000; - y = 64'h3E1FFFFF800007FF; - zrf = 64'hFFDF7FFFFC000000; - ans = 64'hFFDF7FFFFC000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5923257\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5923871\n"); - end - xrf = 64'hBF607FF7FFFFFFFE; - y = 64'h4030000004200000; - zrf = 64'h3FF0000000000000; - ans = 64'h3FEEF8007FBBF021; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5924485\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hC340000000000001; - zrf = 64'h41FFFFF800FFFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5925099\n"); - end - xrf = 64'hFD7000000000FBFF; - y = 64'hFFDDC5AA3804A76F; - zrf = 64'hB7F7FFFFFFFFFFBF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5925713\n"); - end - xrf = 64'h41D0400000000020; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h8010000000000000; - ans = 64'hC53040000000001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5926327\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hC020000008000001; - zrf = 64'hC1C03FDFFFFFFFFE; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5926941\n"); - end - xrf = 64'h4050000000048000; - y = 64'hFFE0000000000000; - zrf = 64'hB80E000002000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5927555\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'h380D5FE325CA93E2; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5928169\n"); - end - xrf = 64'h40C8DE6BC6815A36; - y = 64'h4AF007FFFFDFFFFF; - zrf = 64'hBD7ADF23D4B00144; - ans = 64'h4BC8EADAFC32DE0A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5928783\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'h7FE0000000000000; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5929397\n"); - end - xrf = 64'hC00F9318D73B2ED1; - y = 64'hC01FFFFFFE000010; - zrf = 64'h3FE0000000000001; - ans = 64'h4040098C6AA0FEAA; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5930011\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hFFEFFFFFFFFFFFFE; - zrf = 64'h7FFDFFFFFFFFEFFF; - ans = 64'h7FFDFFFFFFFFEFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5930625\n"); - end - xrf = 64'hB31E001FFFFFFFFF; - y = 64'h3E5FFBFFFFFEFFFE; - zrf = 64'hB960000000000FF6; - ans = 64'hB960000000000FF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5931239\n"); - end - xrf = 64'hC00FFFFFFFFF7BFF; - y = 64'hFFF0000000000001; - zrf = 64'h8000000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5931853\n"); - end - xrf = 64'hFFF0000000000000; - y = 64'hEC0FFFFFFFDEFFFE; - zrf = 64'h3FBFDFFFFFFFFEFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5932467\n"); - end - xrf = 64'hB43C0000007FFFFF; - y = 64'hFFFFFFFFFFFFFFFE; - zrf = 64'hC03F07E096C2D592; + x = 64'hFFE0000000000001; + y = 64'h3CA0000000000000; + z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -454172,19 +131985,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -454200,12 +132013,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5933081\n"); + $fwrite(fp,"5655311\n"); end - xrf = 64'hFFF0000000000000; - y = 64'hC04000000080003F; - zrf = 64'hC010000000000001; - ans = 64'h7FF0000000000000; + x = 64'h3FDFE00000040000; + y = 64'h3CAFFFFFFFFFFFFE; + z = 64'h4C80000008800000; + ans = 64'h4C80000008800000; rn = 1; rz = 0; rm = 0; @@ -454219,19 +132032,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -454247,12 +132060,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5933695\n"); + $fwrite(fp,"5657325\n"); end - xrf = 64'hC03003FFFFBFFFFF; - y = 64'hF79FEFFFFFFFBFFF; - zrf = 64'h7FDD10B61543FF89; - ans = 64'h7FDD10B61543FF89; + x = 64'hBFDFFFFFF0003FFF; + y = 64'hB7EFFFFFFE00000F; + z = 64'hC000000000FFFFF0; + ans = 64'hC000000000FFFFF0; rn = 1; rz = 0; rm = 0; @@ -454266,19 +132079,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -454294,12 +132107,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5934309\n"); + $fwrite(fp,"5659339\n"); end - xrf = 64'hFFF0000000000001; - y = 64'h0000000000000001; - zrf = 64'h4340000000000001; - ans = 64'hFFF8000000000001; + x = 64'hFFE0000000000001; + y = 64'h3FE0000000000000; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hFFD0000000000001; rn = 1; rz = 0; rm = 0; @@ -454313,19 +132126,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -454341,12 +132154,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5934923\n"); + $fwrite(fp,"5661353\n"); end - xrf = 64'h00CFFFFFFEFFFF7E; - y = 64'h99D000000002001F; - zrf = 64'h3FDFFFFFFFFFFFFF; - ans = 64'h3FDFFFFFFFFFFFFF; + x = 64'hC0CE6B6DEFF071A3; + y = 64'h3FEFFFFFFFFFFFFE; + z = 64'h3F9FF00000FFFFFE; + ans = 64'hC0CE6B69F1F07181; rn = 1; rz = 0; rm = 0; @@ -454360,19 +132173,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -454388,12 +132201,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5935537\n"); + $fwrite(fp,"5663367\n"); end - xrf = 64'hFFF0000000000001; - y = 64'h000FFFFFFFFFFFFF; - zrf = 64'hA15FFFFFF8000FFE; - ans = 64'hFFF8000000000001; + x = 64'hEB6FFFFFF7FFFF7F; + y = 64'h40B000800000001F; + z = 64'hC1CFFFFFC0000010; + ans = 64'hEC30007FFBFFDFDE; rn = 1; rz = 0; rm = 0; @@ -454407,19 +132220,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -454435,12 +132248,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5936151\n"); + $fwrite(fp,"5665381\n"); end - xrf = 64'h41D0000102000000; - y = 64'hC04FFFFFFFFE0FFF; - zrf = 64'h37EC9B2D4B5EE9B8; - ans = 64'hC230000101FF07FF; + x = 64'hFFE0000000000001; + y = 64'h4000000000000000; + z = 64'h3FF0000000000001; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -454454,19 +132267,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -454482,11 +132295,293 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5936765\n"); + $fwrite(fp,"5667395\n"); end - xrf = 64'h3F507FFFFFBFFFFF; - y = 64'h0010000000000000; - zrf = 64'h7FFFFFFFFFFFFFFF; + x = 64'h43DFFFFFFFFF7BFF; + y = 64'h400FFFFFFFFFFFFF; + z = 64'hC9E8F802949944EB; + ans = 64'hC9E8F802949944EB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5669409\n"); + end + x = 64'hBFCFF8000003FFFF; + y = 64'hC0C00000007FBFFF; + z = 64'hBFF0000001000007; + ans = 64'h409FF4000103001D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5671423\n"); + end + x = 64'hFFE0000000000001; + y = 64'h401FFFFFFFFFFFFE; + 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,"5673437\n"); + end + x = 64'h41E9904CF9E46D4D; + y = 64'h434FFFFFFFFFFFFF; + z = 64'hB7FFFFF9FFFFFFFF; + ans = 64'h4549904CF9E46D4C; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5675451\n"); + end + x = 64'hC1300003FFFFC000; + y = 64'h316FFFFFFFE1FFFF; + z = 64'h47E00020FFFFFFFF; + ans = 64'h47E00020FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"5677465\n"); + end + x = 64'hFFE0000000000001; + y = 64'h7FEFFFFFFFFFFFFE; + 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,"5679479\n"); + end + x = 64'h8026FB49EB7370B2; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hC1600200000003FF; ans = 64'h7FFFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -454501,19 +132596,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -454529,12 +132624,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5937379\n"); + $fwrite(fp,"5681493\n"); end - xrf = 64'hFFF0000000000001; - y = 64'h3C6FFFFFF7FDFFFE; - zrf = 64'h43C000100000003F; - ans = 64'hFFF8000000000001; + x = 64'hBE90E49A299E9782; + y = 64'h3F5000000FC00000; + z = 64'h401FFFFFFC000004; + ans = 64'h401FFFFFFBFBC6DD; rn = 1; rz = 0; rm = 0; @@ -454548,19 +132643,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -454576,12 +132671,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5937993\n"); + $fwrite(fp,"5683507\n"); end - xrf = 64'h3D600000000000FC; - y = 64'h001FFFFFFFFFFFFF; - zrf = 64'hBE8003FFFDFFFFFF; - ans = 64'hBE8003FFFDFFFFFF; + x = 64'hFFE0000000000001; + y = 64'h800FFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'h3FFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -454595,19 +132690,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -454623,12 +132718,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5938607\n"); + $fwrite(fp,"5685521\n"); end - xrf = 64'hFFF0000000000001; - y = 64'hAD9000FFBFFFFFFE; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hFFF8000000000001; + x = 64'h40907FFFDFFFFFFE; + y = 64'h8010000000000001; + z = 64'hBFA03EFFFFFFFFFF; + ans = 64'hBFA03EFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -454642,19 +132737,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -454670,12 +132765,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5939221\n"); + $fwrite(fp,"5687535\n"); end - xrf = 64'hBC1D8B20936545E0; - y = 64'h355000000043FFFF; - zrf = 64'h480FF7FFFFFFFFFE; - ans = 64'h480FF7FFFFFFFFFE; + x = 64'h403FFFFFFFFFFFFE; + y = 64'hBFFFFC0FFFFFFFFE; + z = 64'hC7E00000001F7FFE; + ans = 64'hC7E00000001F7FFE; rn = 1; rz = 0; rm = 0; @@ -454689,19 +132784,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -454717,12 +132812,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5939835\n"); + $fwrite(fp,"5689549\n"); end - xrf = 64'hFFF0000000000001; - y = 64'h3CA0000000000000; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'hFFF8000000000001; + x = 64'hFFE0000000000001; + y = 64'hBCAFFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'h7CA0000000000000; rn = 1; rz = 0; rm = 0; @@ -454736,19 +132831,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -454764,12 +132859,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5940449\n"); + $fwrite(fp,"5691563\n"); end - xrf = 64'hC03FFFFFFFFFFFFE; - y = 64'hBFC9E093704781EC; - zrf = 64'h3CAFFFFFFFFFFFFE; - ans = 64'h4019E093704781EB; + x = 64'hBE7DFFFFFFFFBFFF; + y = 64'hBFD0000000000001; + z = 64'h48A000000FFF7FFE; + ans = 64'h48A000000FFF7FFE; rn = 1; rz = 0; rm = 0; @@ -454783,19 +132878,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -454811,12 +132906,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5941063\n"); + $fwrite(fp,"5693577\n"); end - xrf = 64'hFFF0000000000001; - y = 64'h3CA0000000000001; - zrf = 64'hC0C003FF7FFFFFFF; - ans = 64'hFFF8000000000001; + x = 64'hC0C01F0000000000; + y = 64'h3FF0001FFF7FFFFF; + z = 64'hBE12DD4B694FB5D8; + ans = 64'hC0C01F203D7F0A5B; rn = 1; rz = 0; rm = 0; @@ -454830,19 +132925,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -454858,481 +132953,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5941677\n"); + $fwrite(fp,"5695591\n"); end - xrf = 64'h403FFFFFFFFFFFFF; - y = 64'hC2B0000000000000; - zrf = 64'hB9FFFFFFFFBFDFFF; - ans = 64'hC2FFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5942291\n"); - end - xrf = 64'h3800007EFFFFFFFF; - y = 64'h3CAFFFFFFFFFFFFE; - zrf = 64'h7FEFFFFFFFFFFFFE; - ans = 64'h7FEFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5942905\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h3DD0000000FDFFFF; - zrf = 64'hB2C00FFFF0000000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5943519\n"); - end - xrf = 64'h43EFFFDFDFFFFFFE; - y = 64'h3FD0000000000000; - zrf = 64'hBFCA49C67AAA31B9; - ans = 64'h43CFFFDFDFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5944133\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'hC3F0F6B14AB3F2C1; - zrf = 64'hBFFFFFFFFFFFFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5944747\n"); - end - xrf = 64'h4800100FFFFFFFFE; - y = 64'hC1D000000007FC00; - zrf = 64'hBFDFFF0000004000; - ans = 64'hC9E0101000080402; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5945361\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h400FFFFFFFFFFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5945975\n"); - end - xrf = 64'h3FA011FFFFFFFFFF; - y = 64'h800FFEFFFFFF7FFE; - zrf = 64'h3CA0000000000000; - ans = 64'h3CA0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5946589\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h3FE0000000000000; - zrf = 64'h3EEFBFFFFFFFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5947203\n"); - end - xrf = 64'hC02FF000003FFFFF; - y = 64'h41C37AD8B361617C; - zrf = 64'h41C767C82EC1CD63; - ans = 64'hC201FA9EC44289A6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5947817\n"); - end - xrf = 64'h41D0000400FFFFFE; - y = 64'h3FEFFFFFFFFFFFFF; - zrf = 64'h7FE0000000000000; + x = 64'hFFE0000000000001; + y = 64'hBFEFFFFFFFFFFFFF; + z = 64'h4340000000000000; ans = 64'h7FE0000000000000; rn = 1; rz = 0; @@ -455347,19 +132972,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -455375,12 +133000,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5948431\n"); + $fwrite(fp,"5697605\n"); end - xrf = 64'hFFF0000000000001; - y = 64'hC801FFFFFFF80000; - zrf = 64'h460FFFFFFFC0003F; - ans = 64'hFFF8000000000001; + x = 64'h3F7451E3E906A160; + y = 64'hBFF0000000000000; + z = 64'h37E080000000003F; + ans = 64'hBF7451E3E906A160; rn = 1; rz = 0; rm = 0; @@ -455394,19 +133019,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -455422,12 +133047,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5949045\n"); + $fwrite(fp,"5699619\n"); end - xrf = 64'h4F6DFFFFFFFFFDFE; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'h403FFFFF7FFBFFFE; - ans = 64'h4F6DFFFFFFFFFDFC; + x = 64'hC34FFFDFFFFF7FFF; + y = 64'hC7FFFFFF7FFF7FFE; + z = 64'hBFDFFFFFFEFFF800; + ans = 64'h4B5FFFDF7FFF7FFE; rn = 1; rz = 0; rm = 0; @@ -455441,19 +133066,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -455469,998 +133094,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5949659\n"); + $fwrite(fp,"5701633\n"); end - xrf = 64'hFFF0000000000001; - y = 64'h3EFFFF7FFF7FFFFF; - zrf = 64'hBFF0000000000000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5950273\n"); - end - xrf = 64'hEB3F000000000000; - y = 64'h47EBFFFFFFFFFF80; - zrf = 64'h40019959BA20557B; - ans = 64'hF33B1FFFFFFFFF84; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5950887\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'h4000000000000000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5951501\n"); - end - xrf = 64'hC1E44A5016328078; - y = 64'hC01FFFFFFC020000; - zrf = 64'h0010000000000001; - ans = 64'h42144A5013AA7B1A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5952115\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h3FFFFFFFFFFFFFFE; - zrf = 64'h37E00000003FFFFC; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5952729\n"); - end - xrf = 64'h4501FFFFFFFFFFFF; - y = 64'hE830000000000102; - zrf = 64'h3FDD72BA744EEBA8; - ans = 64'hED42000000000121; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5953343\n"); - end - xrf = 64'hC3DFFFFFB7FFFFFE; - y = 64'h4000000000000001; - zrf = 64'h4340000000000001; - ans = 64'hC3EFFBFFB8000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5953957\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h3E1FFFBFFBFFFFFF; - zrf = 64'h43D0400000008000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5954571\n"); - end - xrf = 64'hBFB01FFFFFFFFF7F; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'hB0BCFFFFFFFFFFFF; - ans = 64'hBFD01FFFFFFFFF7E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5955185\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h9A60041FFFFFFFFF; - zrf = 64'hBFE0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5955799\n"); - end - xrf = 64'hC1FFFFFBFFFFFFEE; - y = 64'hC7E2EC12B495AC07; - zrf = 64'hC075A96A9FAD2C84; - ans = 64'h49F2EC105713556A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5956413\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h4010000000000001; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5957027\n"); - end - xrf = 64'hFFF00001FFFEFFFF; - y = 64'h0A4003FFFFFFFFDF; - zrf = 64'h000FFFFFFFFFFFFF; - ans = 64'hFFF80001FFFEFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5957641\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h401FFFFFFFFFFFFF; - zrf = 64'hBFD75C4F46DFE315; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5958255\n"); - end - xrf = 64'h37F0007FFFFFF800; - y = 64'h403FFFFFFEFFFBFF; - zrf = 64'hC0A001FFF0000000; - ans = 64'hC0A001FFF0000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5958869\n"); - end - xrf = 64'hC1800000007FFFFE; - y = 64'h4340000000000000; - zrf = 64'h401FFFFFFFFFFFFF; - ans = 64'hC4D00000007FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5959483\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'hCECFFFFFFFF82000; - zrf = 64'hC30FFFFFFFFFFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5960097\n"); - end - xrf = 64'h606F7FFFFFFFFFFD; - y = 64'h4340000000000001; - zrf = 64'h7FF09ADFB296CCA7; - ans = 64'h7FF89ADFB296CCA7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5960711\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'hBFCFFFFFFFFF9FFE; - zrf = 64'hBFDFFFFFFFFFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5961325\n"); - end - xrf = 64'hBFDFFFEFDFFFFFFF; - y = 64'h97400007FFFFFFFE; - zrf = 64'hBFC004007FFFFFFF; - ans = 64'hBFC004007FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5961939\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h7FE0000000000000; - zrf = 64'h3FEFFFFFFFFFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5962553\n"); - end - xrf = 64'hC0D9642D86C4ADA0; - y = 64'hE6D00003FFFFFF80; - zrf = 64'hFFFFFFFFFFFFFFFE; + x = 64'hFFE0000000000001; + y = 64'hC000000000000001; + z = 64'hFFFFFFFFFFFFFFFE; ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -456475,19 +133113,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -456503,2127 +133141,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5963167\n"); + $fwrite(fp,"5703647\n"); end - xrf = 64'hFFF0000000000001; - y = 64'h7FE0000000000001; - zrf = 64'hB23FFFFFEFFFFFFB; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5963781\n"); - end - xrf = 64'h4664ADCED9E7C577; - y = 64'hC1D7328061FEA34E; - zrf = 64'h4806833B7548D024; - ans = 64'hC84C92EAB56F32AC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5964395\n"); - end - xrf = 64'h2BBE00000007FFFE; - y = 64'h7FEFFFFFFFFFFFFE; - zrf = 64'h400FFFFFFFFFFFFE; - ans = 64'h6BBE00000007FFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5965009\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h403FFFFFFFF80000; - zrf = 64'h7FDDFFEFFFFFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5965623\n"); - end - xrf = 64'hBFDFFF7FFBFFFFFE; - y = 64'h7FF0000000000000; - zrf = 64'h398FFFFFFFBFFEFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5966237\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h2C5EF584D2921263; - zrf = 64'hBCAFFFFFFFFFFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5966851\n"); - end - xrf = 64'h7FEFFFF8007FFFFF; - y = 64'h3D36521B0E02D649; - zrf = 64'hC1F71FEB650BA23E; - ans = 64'h7D36521579D55B34; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5967465\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h7FFFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5968079\n"); - end - xrf = 64'h400518C3F3C93739; - y = 64'h241FFFEFFFFFFFBF; - zrf = 64'hFFF0000000000000; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5968693\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h8000000000000000; - zrf = 64'h434FFFE01FFFFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5969307\n"); - end - xrf = 64'hC3EFFFFFFF8001FF; - y = 64'hFFEADF2D3E923580; - zrf = 64'h401355BD593A7BDF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5969921\n"); - end - xrf = 64'h4010000400001000; - y = 64'h800FFFFFFFFFFFFF; - zrf = 64'h4000000000000000; - ans = 64'h4000000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5970535\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h32ABFFFFFEFFFFFF; - zrf = 64'h4110000000000046; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5971149\n"); - end - xrf = 64'hC7F01FFFFFFF8000; - y = 64'h800FFFFFFFFFFFFE; - zrf = 64'hC40FFFEFFFFFFFEF; - ans = 64'hC40FFFEFFFFFFFEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5971763\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'hBFCFFFEFFFFFFFFF; - zrf = 64'hBCA0000000000000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5972377\n"); - end - xrf = 64'h3FB0021FFFFFFFFF; - y = 64'h001000000000FFF0; - zrf = 64'h434BF47892849E26; - ans = 64'h434BF47892849E26; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5972991\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h801FFFFFFFFFFFFF; - zrf = 64'h3FD0000000000000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5973605\n"); - end - xrf = 64'hBCAFFF000FFFFFFE; - y = 64'h300400003FFFFFFE; - zrf = 64'hFFE0000000000001; - ans = 64'hFFE0000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5974219\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h801FFFFFFFFFFFFE; - zrf = 64'h400000FFFFFFFFEE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5974833\n"); - end - xrf = 64'h79D000004000003F; - y = 64'hEA5C751C34FE794B; - zrf = 64'h434FFFF7FFFFFFFD; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5975447\n"); - end - xrf = 64'h43D00010000000FE; - y = 64'hBCA0000000000001; - zrf = 64'h3FF0000000000001; - ans = 64'hC07FF020000001FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5976061\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'hA52FFF0000000006; - zrf = 64'hB90FFFFFFFFFDF80; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5976675\n"); - end - xrf = 64'hC04FFFEFFFDFFFFE; - y = 64'hBCAFFFFFFFFFFFFF; - zrf = 64'h371FFFFFFFF7F000; - ans = 64'h3D0FFFEFFFDFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5977289\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h002FFF7FFDFFFFFE; - zrf = 64'h8010000000000001; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5977903\n"); - end - xrf = 64'hC03FEFFFFFFFDFFF; - y = 64'h3FB087FFFFFFFFFE; - zrf = 64'hAC2BFFFFFFFDFFFE; - ans = 64'hC0007FBBFFFFEF75; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5978517\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'hBFD0000000000001; - zrf = 64'h3CA0000000000001; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5979131\n"); - end - xrf = 64'h300AD1F75B73EA35; - y = 64'h3FD1080000000000; - zrf = 64'hC34FFFFFFFFFFFFF; - ans = 64'hC34FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5979745\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'hBFDFFFFFFFFFFFFF; - zrf = 64'hBFF00003FFFEFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5980359\n"); - end - xrf = 64'hC00FFFFFFF8000FF; - y = 64'h43E00000801FFFFF; - zrf = 64'hC3D58C6D00AD1645; - ans = 64'hC402B18E1FF5A345; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5980973\n"); - end - xrf = 64'h800D6783375924E4; - y = 64'hBFE0000000000000; - zrf = 64'h3FEFFFFFFFFFFFFF; - ans = 64'h3FEFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5981587\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h480000000801FFFE; - zrf = 64'h000000000000BFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5982201\n"); - end - xrf = 64'hBCA42290E4492F97; - y = 64'hBFE0000000000001; - zrf = 64'hCCCFFFFFFF3FFFFE; - ans = 64'hCCCFFFFFFF3FFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5982815\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'hCB5FFFFFFF200000; - zrf = 64'h800FFFFFFFFFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5983429\n"); - end - xrf = 64'h43FFFF7FFFFFFF7E; - y = 64'h3FF1EF9A75012B02; - zrf = 64'hFFDE000000004000; - ans = 64'hFFDE000000004000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5984043\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'hBFF0000000000000; - zrf = 64'h001FFFFFFFFFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5984657\n"); - end - xrf = 64'h43EFFFFFFF0007FF; - y = 64'h4015D28480825D19; - zrf = 64'hC01FFFFFFFFFFFFE; - ans = 64'h4415D2847FD3CE69; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5985271\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'hBFF0000000000001; - zrf = 64'hBFAFF0001FFFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5985885\n"); - end - xrf = 64'h000FE003FFFFFFFF; - y = 64'hC34F20604C16D66F; - zrf = 64'hC1F000000000FBFE; - ans = 64'hC1F000000000FBFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5986499\n"); - end - xrf = 64'h3C52FF4CCF4DE0C0; - y = 64'hBFFFFFFFFFFFFFFE; - zrf = 64'h3FDFFFFFFFFFFFFE; - ans = 64'h3FDFFFFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5987113\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h0028850B7A2ABE24; - zrf = 64'hC3F0717F02542F9E; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5987727\n"); - end - xrf = 64'h4FDF49A6E542B789; - y = 64'hC000000000000000; - zrf = 64'h43FFFFFF7F7FFFFF; - ans = 64'hCFEF49A6E542B789; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5988341\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h80287908BD1C926F; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5988955\n"); - end - xrf = 64'h3C8FFFFFFFFFFFFE; - y = 64'hB802000000003FFF; - zrf = 64'hC0A2000000200000; - ans = 64'hC0A2000000200000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5989569\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'hC00FFFFFFFFFFFFE; - zrf = 64'h000FFFFFFFFFFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5990183\n"); - end - xrf = 64'hC3FFDF7FFFFFFFFE; - y = 64'h02501003FFFFFFFF; - zrf = 64'hC010000000000000; - ans = 64'hC010000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5990797\n"); - end - xrf = 64'hFFF0000000000001; + x = 64'h243F9FFFFFFFFFFF; y = 64'hC010000000000000; - zrf = 64'hBC4E882DDE86F4D2; - ans = 64'hFFF8000000000001; + z = 64'h401007FBFFFFFFFF; + ans = 64'h401007FBFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -458637,19 +133160,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -458665,12 +133188,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5991411\n"); + $fwrite(fp,"5705661\n"); end - xrf = 64'h334FFFFFFFFFF7FD; - y = 64'h554E764D69758DFB; - zrf = 64'h7FF003FFFDFFFFFF; - ans = 64'h7FF803FFFDFFFFFF; + x = 64'h3F8003FFFFFFDFFF; + y = 64'h3FC81AD9D396573D; + z = 64'h43F0000FFFFFFFF0; + ans = 64'h43F0000FFFFFFFF0; rn = 1; rz = 0; rm = 0; @@ -458684,19 +133207,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -458712,1656 +133235,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5992025\n"); + $fwrite(fp,"5707675\n"); end - xrf = 64'h3FDFDFFFFFFFFFDF; - y = 64'hC01FFFFFFFFFFFFF; - zrf = 64'h3FD0000000000000; - ans = 64'hC00DDFFFFFFFFFDE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5992639\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h412000000001001E; - zrf = 64'h403008000000007F; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5993253\n"); - end - xrf = 64'hC12FFFFFFFFFFEFC; - y = 64'hC01FFFFFFFFFFFFE; - zrf = 64'h400FFFEFFFDFFFFF; - ans = 64'h416000007FFFBF7C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5993867\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'hBFB7913774310F6A; - zrf = 64'h7FF0000000000000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5994481\n"); - end - xrf = 64'hC1CFFFFF7FFFFFFF; - y = 64'hBF8913BACCCC2196; - zrf = 64'h00189122A75A73CF; - ans = 64'h416913BA687D3662; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5995095\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'hC34FFFFFFFFFFFFF; - zrf = 64'h0000000000000000; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5995709\n"); - end - xrf = 64'hBFCFFFFFFFEFFEFE; - y = 64'hC52FFFFC000003FE; - zrf = 64'hC000000000000001; - ans = 64'h450FFFFBFFF002FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5996323\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'hC34FFFFFFFFFFFFE; - zrf = 64'hC3E0000800000007; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5996937\n"); - end - xrf = 64'h450FFFFFB8000000; - y = 64'h381E0148BF287BAC; - zrf = 64'h3FCFFFFFFFFFC000; - ans = 64'h3FCFFFFFFFFFCF01; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5997551\n"); - end - xrf = 64'h23C1003FFFFFFFFF; - y = 64'hFFE0000000000001; - zrf = 64'h3CA0000000000001; - ans = 64'hE3B1004000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5998165\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h7FE01FFFFFFFFFFC; - zrf = 64'h3FBFFFFFFDFBFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5998779\n"); - end - xrf = 64'hBFCAFEDB9EF66935; - y = 64'hFFEFFFFFFFFFFFFF; - zrf = 64'hBF2007FFFFFF7FFF; - ans = 64'h7FCAFEDB9EF66934; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5999393\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'h43E008000007FFFF; - zrf = 64'h7FE0000000000001; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6000007\n"); - end - xrf = 64'hCE34267CF2FD83B4; - y = 64'h41FBFFFDFFFFFFFF; - zrf = 64'hA9EFFDFFFFFFC000; - ans = 64'hD041A1AC1236040D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6000621\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'hFFF0000000000000; - zrf = 64'hFFF0000000000001; - ans = 64'hFFF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6001235\n"); - end - xrf = 64'hFFEFFFFFFFFFFFFE; - y = 64'h3FF00000007FFFEE; - zrf = 64'hBFFFFFFFFFFFFFFF; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6001849\n"); - end - xrf = 64'hFFF0000000000001; - y = 64'hFFFFFFFFFFFFFFFF; - zrf = 64'hC3DFFFFFF7FFFF7F; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6002463\n"); - end - xrf = 64'hBDF8D9D1DB68753E; - y = 64'hFFF0000000001007; - zrf = 64'hBFE324032D7380A1; - ans = 64'hFFF8000000001007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6003077\n"); - end - xrf = 64'h43CDFFFFFFFFFFDE; - y = 64'h0000000000000000; - zrf = 64'h001FFFFFFFFFFFFF; - ans = 64'h001FFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6003691\n"); - end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h38000004000001FE; - zrf = 64'h7FFFFFFFFFDFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6004305\n"); - end - xrf = 64'h001FFF80000000FE; - y = 64'h0000000000000001; - zrf = 64'h3FC41DFAF30EB2A7; - ans = 64'h3FC41DFAF30EB2A7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6004919\n"); - end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h43258AB726B6A526; - zrf = 64'h434FFFFFFFFFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6005533\n"); - end - xrf = 64'hC004604F5E7C16EA; - y = 64'h41FF71DB9A787CF5; - zrf = 64'hC7E6449832CF8766; - ans = 64'hC7E6449832CF8766; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6006147\n"); - end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFE; - zrf = 64'hFFEFFFFFFFFFFFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6006761\n"); - end - xrf = 64'hC80000000000077E; - y = 64'hBFDB0BAEE1431D3F; - zrf = 64'hBFEFFFFFFFFFFFFE; - ans = 64'h47EB0BAEE14329E9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6007375\n"); - end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h0010000000000001; - zrf = 64'hBE70200000003FFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6007989\n"); - end - xrf = 64'h801FFFBFFFFEFFFF; - y = 64'hC1D000000040001F; - zrf = 64'hC0312172B6EA7FC8; - ans = 64'hC0312172B6EA7FC8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6008603\n"); - end - xrf = 64'h40200FFFFFFE0000; - y = 64'h001FFFFFFFFFFFFE; - zrf = 64'h000FFFFFFFFFFFFE; - ans = 64'h00510FFFFFFDFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6009217\n"); - end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'hC7EE648E4ED12A6E; - zrf = 64'hBFE0008000001FFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6009831\n"); - end - xrf = 64'hBFCFFFFFE0000002; - y = 64'h3CA0000000000000; - zrf = 64'h43B7A97D7F60ECC2; - ans = 64'h43B7A97D7F60ECC2; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6010445\n"); - end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'hBFBFFFFFE01FFFFF; - zrf = 64'h401FFFFFFFFFFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6011059\n"); - end - xrf = 64'hBFDFFFFFFE07FFFF; - y = 64'h43FB1620669319E9; - zrf = 64'hBCFFFFFFF80001FF; - ans = 64'hC3EB162064E87D6A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6011673\n"); - end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h3CAFFFFFFFFFFFFF; - zrf = 64'hC34FFFFFFFFFFFFE; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6012287\n"); - end - xrf = 64'hBCFFBFFDFFFFFFFF; - y = 64'h49EF8000000003FE; - zrf = 64'hBFE0000000000000; - ans = 64'hC6FF40FE080003F5; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6012901\n"); - end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h3FD0000000000000; - zrf = 64'hBFD4000000000001; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6013515\n"); - end - xrf = 64'hFF9DCF3138A00E7C; - y = 64'hC0F01FFFFF7FFFFE; - zrf = 64'h43E4000000000020; + x = 64'hFFE0000000000001; + y = 64'hC340000000000001; + z = 64'hBCAFFFFFFFFFFFFF; ans = 64'h7FF0000000000000; rn = 1; rz = 0; @@ -460376,19 +133254,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -460404,12 +133282,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6014129\n"); + $fwrite(fp,"5709689\n"); end - xrf = 64'h4340000000002400; - y = 64'h3FDFFFFFFFFFFFFF; - zrf = 64'h0000000000000000; - ans = 64'h43300000000023FF; + x = 64'hC0210000000FFFFF; + y = 64'hFFE0000000000000; + z = 64'hC0F19E8F60E66EF1; + ans = 64'h7FF0000000000000; rn = 1; rz = 0; rm = 0; @@ -460423,19 +133301,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -460451,12 +133329,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6014743\n"); + $fwrite(fp,"5711703\n"); end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'hBE500000FFFFFFDE; - zrf = 64'h275000001FFFFFBE; - ans = 64'hFFFFFFFFFFFFFFFF; + x = 64'hBCA0000007FEFFFE; + y = 64'hC1F1000003FFFFFF; + z = 64'h3FE000007FFFFBFF; + ans = 64'h3FE000018FFFFCC7; rn = 1; rz = 0; rm = 0; @@ -460470,19 +133348,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -460498,340 +133376,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6015357\n"); + $fwrite(fp,"5713717\n"); end - xrf = 64'hC01FFFFFF8000001; - y = 64'h3FDFFFFFFFFFFFFE; - zrf = 64'h3FBFFFFFFFBFFEFF; - ans = 64'hC00EFFFFF8020007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6015971\n"); - end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'hBFA040001FFFFFFF; - zrf = 64'h4010000000000000; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6016585\n"); - end - xrf = 64'hC3400000007DFFFE; - y = 64'hBD625ADDFE5EDA57; - zrf = 64'hC7E8B8D2A9ED99EB; - ans = 64'hC7E8B8D2A9ED99EB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6017199\n"); - end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h3FE0000000000001; - zrf = 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6017813\n"); - end - xrf = 64'h3FBFFFF80FFFFFFF; - y = 64'hC05FF0000000001F; - zrf = 64'hBFD0000000000001; - ans = 64'hC03037FC09FC000F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6018427\n"); - end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFE; - zrf = 64'hC805734C0C30B9A6; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6019041\n"); - end - xrf = 64'hBD57FB5BF9124DE0; - y = 64'hB070004000000006; - zrf = 64'h43D000000400003E; - ans = 64'h43D000000400003E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6019655\n"); - end - xrf = 64'h43FDFFFDFFFFFFFF; - y = 64'h3FF0000000000000; - zrf = 64'hFFF0000000000001; + x = 64'hFFE0000000000001; + y = 64'hFFF0000000000001; + z = 64'h3FF0000000000001; ans = 64'hFFF8000000000001; rn = 1; rz = 0; @@ -460846,19 +133395,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -460874,12 +133423,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6020269\n"); + $fwrite(fp,"5715731\n"); end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h0014B3708D32AD76; - zrf = 64'h3FFFFFE001000000; - ans = 64'hFFFFFFFFFFFFFFFF; + x = 64'h3F29E1BCF47D151E; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'hAD2DB2FBA0FDA091; + ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -460893,19 +133442,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -460921,12 +133470,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6020883\n"); + $fwrite(fp,"5717745\n"); end - xrf = 64'h303FFE0000000002; - y = 64'h3FFFFFFFFFFFFFFF; - zrf = 64'hFFE0000FFEFFFFFF; - ans = 64'hFFE0000FFEFFFFFF; + x = 64'h800FFFBFFFF00000; + y = 64'hBFFE01FFFFFFFFFF; + z = 64'h422FFFFEFF7FFFFF; + ans = 64'h422FFFFEFF7FFFFF; rn = 1; rz = 0; rm = 0; @@ -460940,19 +133489,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -460968,12 +133517,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6021497\n"); + $fwrite(fp,"5719759\n"); end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h5F7000000FFFFFFB; - zrf = 64'h4000000000000001; - ans = 64'hFFFFFFFFFFFFFFFF; + x = 64'hFFEFFFFFFFFFFFFF; + y = 64'h0010000000000000; + z = 64'hC340000000000000; + ans = 64'hC340000000000002; rn = 1; rz = 0; rm = 0; @@ -460987,19 +133536,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -461015,12 +133564,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6022111\n"); + $fwrite(fp,"5721773\n"); end - xrf = 64'hC0000001FFFDFFFF; - y = 64'hC03000007FFFFFFF; - zrf = 64'h48E03F7FFFFFFFFE; - ans = 64'h48E03F7FFFFFFFFE; + x = 64'hB7FFFFF80000001F; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h800FFFFFFFFF07FF; + ans = 64'h800FFFFFFFFF07FF; rn = 1; rz = 0; rm = 0; @@ -461034,19 +133583,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -461062,12 +133611,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6022725\n"); + $fwrite(fp,"5723787\n"); end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h4000000000000000; - zrf = 64'hC010000000000001; - ans = 64'hFFFFFFFFFFFFFFFF; + x = 64'h3FDFFFFF0000000F; + y = 64'hF540000000EFFFFE; + z = 64'h4954D5A68860848B; + ans = 64'hF52FFFFF01DFFFFC; rn = 1; rz = 0; rm = 0; @@ -461081,19 +133630,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -461109,12 +133658,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6023339\n"); + $fwrite(fp,"5725801\n"); end - xrf = 64'hC1F000002FFFFFFF; - y = 64'hC02745A0F483004D; - zrf = 64'hBCAFFFFFFFFFFFFF; - ans = 64'h422745A13A53E329; + x = 64'hFFEFFFFFFFFFFFFF; + y = 64'h3FD0000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -461128,19 +133677,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -461156,12 +133705,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6023953\n"); + $fwrite(fp,"5727815\n"); end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFF; - zrf = 64'h3FAE800000000000; - ans = 64'hFFFFFFFFFFFFFFFF; + x = 64'h3FDFFFFF80007FFF; + y = 64'h3FDFFFFFFFFFFFFE; + z = 64'h402001FFFFFFFFE0; + ans = 64'h402081FFFE0001E0; rn = 1; rz = 0; rm = 0; @@ -461175,19 +133724,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -461203,12 +133752,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6024567\n"); + $fwrite(fp,"5729829\n"); end - xrf = 64'hBEABFFF000000000; - y = 64'hBCA00010007FFFFF; - zrf = 64'h3807FFFFFFFF7FFF; - ans = 64'h3B5C000C00CFFF7F; + x = 64'h3EB17B46105C029E; + y = 64'h356FFFF80007FFFF; + z = 64'hBFCFFFFFE0001FFE; + ans = 64'hBFCFFFFFE0001FFE; rn = 1; rz = 0; rm = 0; @@ -461222,19 +133771,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -461250,11 +133799,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6025181\n"); + $fwrite(fp,"5731843\n"); end - xrf = 64'h40503FDFFFFFFFFE; - y = 64'h400FFFFFFFFFFFFE; - zrf = 64'hFFEFFFFFFFFFFFFF; + x = 64'hFFEFFFFFFFFFFFFF; + y = 64'h3FF0000000000000; + z = 64'h3CAFFFFFFFFFFFFF; ans = 64'hFFEFFFFFFFFFFFFF; rn = 1; rz = 0; @@ -461269,19 +133818,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -461297,12 +133846,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6025795\n"); + $fwrite(fp,"5733857\n"); end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'hCCA3BD9D74CC895A; - zrf = 64'h3CACC405BD82F4C5; - ans = 64'hFFFFFFFFFFFFFFFF; + x = 64'h43F008000000003E; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'hC3DC8B92C412FD96; + ans = 64'h43F8ED1B4EFB4115; rn = 1; rz = 0; rm = 0; @@ -461316,19 +133865,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -461344,12 +133893,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6026409\n"); + $fwrite(fp,"5735871\n"); end - xrf = 64'hC0DFFFF000000006; - y = 64'h4010000000000001; - zrf = 64'h417127C239D6F2F3; - ans = 64'h417107C249D6F2F3; + x = 64'hC1E6DAF608F120DA; + y = 64'hBFDF9FA3B892B56B; + z = 64'hB7E07FFFFFFFC000; + ans = 64'h41D696233E4F12C4; rn = 1; rz = 0; rm = 0; @@ -461363,19 +133912,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -461391,12 +133940,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6027023\n"); + $fwrite(fp,"5737885\n"); end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h4141FEFFFFFFFFFE; - zrf = 64'h3FFFFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; + x = 64'hFFEFFFFFFFFFFFFF; + y = 64'h400FFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -461410,19 +133959,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -461438,12 +133987,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6027637\n"); + $fwrite(fp,"5739899\n"); end - xrf = 64'h37E6C010695E7496; - y = 64'hB170004001FFFFFF; - zrf = 64'h40101000003FFFFE; - ans = 64'h40101000003FFFFE; + x = 64'h181040003FFFFFFE; + y = 64'h401FFFFFFFFFFFFF; + z = 64'hFFF000000003FDFF; + ans = 64'hFFF800000003FDFF; rn = 1; rz = 0; rm = 0; @@ -461457,19 +134006,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -461485,12 +134034,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6028251\n"); + $fwrite(fp,"5741913\n"); end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h401FFFFFFFFFFFFE; - zrf = 64'hC00FFFFFFFFFFFFF; - ans = 64'hFFFFFFFFFFFFFFFF; + x = 64'h7FD4100000000000; + y = 64'hBF2FFFFE03FFFFFE; + z = 64'h9E4F275405EB089B; + ans = 64'hFF140FFEC181FFFF; rn = 1; rz = 0; rm = 0; @@ -461504,19 +134053,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -461532,12 +134081,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6028865\n"); + $fwrite(fp,"5743927\n"); end - xrf = 64'h80200FFFFFC00000; - y = 64'h3FB004000000007E; - zrf = 64'h801FFFFFFFFFFFFE; - ans = 64'h802101403FFBFF07; + x = 64'hFFEFFFFFFFFFFFFF; + y = 64'h434FFFFFFFFFFFFE; + z = 64'h4340000000000000; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -461551,19 +134100,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -461579,12 +134128,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6029479\n"); + $fwrite(fp,"5745941\n"); end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h4340000000000001; - zrf = 64'h3FDFE02000000000; - ans = 64'hFFFFFFFFFFFFFFFF; + x = 64'hC7E000004000FFFE; + y = 64'h7FE0000000000001; + z = 64'hC3FFFFFFFAFFFFFE; + ans = 64'hFFF0000000000000; rn = 1; rz = 0; rm = 0; @@ -461598,19 +134147,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -461626,12 +134175,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6030093\n"); + $fwrite(fp,"5747955\n"); end - xrf = 64'h33A00000000100FF; - y = 64'hC1FFFFFE003FFFFF; - zrf = 64'hB7EFFFFFFFFFFFFE; - ans = 64'hB7F000000000FFFF; + x = 64'h434FFF7FFF7FFFFF; + y = 64'hC1DFFFF800000004; + z = 64'h8020081FFFFFFFFF; + ans = 64'hC53FFF77FFA00023; rn = 1; rz = 0; rm = 0; @@ -461645,19 +134194,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -461673,12 +134222,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6030707\n"); + $fwrite(fp,"5749969\n"); end - xrf = 64'hE5A00000001007FF; - y = 64'h434FFFFFFFFFFFFF; - zrf = 64'hC34FFFFFFFFFFFFE; - ans = 64'hE9000000001007FE; + x = 64'hFFEFFFFFFFFFFFFF; + y = 64'h7FFFFFFFFFFFFFFF; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFF; rn = 1; rz = 0; rm = 0; @@ -461692,19 +134241,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -461720,12 +134269,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6031321\n"); + $fwrite(fp,"5751983\n"); end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h4050000038000000; - zrf = 64'hBFF6AFDA66A93310; - ans = 64'hFFFFFFFFFFFFFFFF; + x = 64'h3FADCDBDD2C3F87E; + y = 64'h8000000000000001; + z = 64'h402FFFFFFFE00007; + ans = 64'h402FFFFFFFE00007; rn = 1; rz = 0; rm = 0; @@ -461739,19 +134288,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -461767,11 +134316,340 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6031935\n"); + $fwrite(fp,"5753997\n"); end - xrf = 64'h402FFFFF7FFFF000; - y = 64'h7FE0000000000000; - zrf = 64'hBFA00008FFFFFFFF; + 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; @@ -461786,19 +134664,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -461814,12 +134692,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6032549\n"); + $fwrite(fp,"5770109\n"); end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h8010000000000000; - zrf = 64'h3FEFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFF; + x = 64'h47FFDC0000000000; + y = 64'hC000000000000000; + z = 64'hBFD0000040FFFFFE; + ans = 64'hC80FDC0000000000; rn = 1; rz = 0; rm = 0; @@ -461833,19 +134711,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -461861,12 +134739,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6033163\n"); + $fwrite(fp,"5772123\n"); end - xrf = 64'h02F0000840000000; - y = 64'hBE90001FFFF7FFFF; - zrf = 64'h3DEFFFFFE0000000; - ans = 64'h3DEFFFFFE0000000; + x = 64'h40013FAD9F4E14D4; + y = 64'h8027FFFFFFFF0000; + z = 64'h3FCFFFF800003FFE; + ans = 64'h3FCFFFF800003FFE; rn = 1; rz = 0; rm = 0; @@ -461880,19 +134758,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -461908,293 +134786,11 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6033777\n"); + $fwrite(fp,"5774137\n"); end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h7FEFFFFFFFFFFFFF; - zrf = 64'hBFFFFFFFFFFFFFFE; - ans = 64'hFFFFFFFFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6034391\n"); - end - xrf = 64'hC03773EB99C22A5C; - y = 64'hC0200000000FBFFE; - zrf = 64'h8010000000000000; - ans = 64'h406773EB99D94075; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6035005\n"); - end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h7FF0000000000000; - zrf = 64'hC010000FFFFFBFFF; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6035619\n"); - end - xrf = 64'hB810000000040000; - y = 64'hC03FFFFEFFFF7FFE; - zrf = 64'hBCFD9D3D0BE8C388; - ans = 64'hBCFD9D3D0BE8C388; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6036233\n"); - end - xrf = 64'hBFCFBFFFDFFFFFFE; - y = 64'h7FF0000000000001; - zrf = 64'hC340000000000000; - ans = 64'h7FF8000000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6036847\n"); - end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h47F001FFFFFBFFFE; - zrf = 64'h001B000EF97BA960; - 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 = &xrf[62:52] && |xrf[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6037461\n"); - end - xrf = 64'hA45F7FFFFFFBFFFE; - y = 64'h7FFFFFFFFFFFFFFE; - zrf = 64'h00123CDD537A76C4; + x = 64'hFFEFFFFFFFFFFFFF; + y = 64'hC010000000000001; + z = 64'h7FFFFFFFFFFFFFFE; ans = 64'h7FFFFFFFFFFFFFFE; rn = 1; rz = 0; @@ -462209,19 +134805,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -462237,11 +134833,5087 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6038075\n"); + $fwrite(fp,"5776151\n"); end - xrf = 64'hFFFFFFFFFFFFFFFF; - y = 64'h4012010000000000; - zrf = 64'h3FE0000000000000; + 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; @@ -462256,19 +139928,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -462284,12 +139956,12 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6038689\n"); + $fwrite(fp,"5995677\n"); end - xrf = 64'hC03FF0000FFFFFFE; - y = 64'h3FF9150E22C65E3D; - zrf = 64'hC02FC39584B3CDCD; - ans = 64'hC0507CB484B63AC8; + x = 64'hBFDFFE0001FFFFFE; + y = 64'h31F8000000200000; + z = 64'h37EAD068BEBDB0D3; + ans = 64'h37EAD068BEBDB0D3; rn = 1; rz = 0; rm = 0; @@ -462303,19 +139975,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -462331,12 +140003,2409 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6039303\n"); + $fwrite(fp,"5997691\n"); end - xrf = 64'h41FFFFFFFFFFFF87; + 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 + x = 64'hFFFFFFFFFFFFFFFF; + y = 64'h400FFFFFFFFFFFFF; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6017831\n"); + end + x = 64'h3006575FFA1D85B9; + y = 64'h4010000000000001; + z = 64'hBFEE0000000FFFFF; + ans = 64'hBFEE0000000FFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6019845\n"); + end + x = 64'hD560913EC64375B2; + y = 64'h3D607E0000000000; + z = 64'h381D4C5B808321C8; + ans = 64'hD2D113B6949CC8F1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6021859\n"); + end + x = 64'hFFFFFFFFFFFFFFFF; + y = 64'h434FFFFFFFFFFFFF; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6023873\n"); + end + x = 64'h403FFFFFFFFFC3FE; + y = 64'h7FE0000000000000; + z = 64'hC0200FFFFFFF7FFF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6025887\n"); + end + x = 64'hC070080FFFFFFFFF; + y = 64'hB8A0000002000080; + z = 64'h7FF82DBA502B3839; + ans = 64'h7FF82DBA502B3839; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6027901\n"); + end + x = 64'hFFFFFFFFFFFFFFFF; + y = 64'h7FF0000000000001; + z = 64'hBFF0000000000001; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6029915\n"); + end + x = 64'h3CA0000800004000; + y = 64'h8000000000000000; + z = 64'hBF9FFFF1FFFFFFFF; + ans = 64'hBF9FFFF1FFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6031929\n"); + end + x = 64'h38FFFFFFFFFDC000; + y = 64'h41E00001FFFFFFBE; + z = 64'hD52000000000801E; + ans = 64'hD52000000000801E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6033943\n"); + end + x = 64'hFFFFFFFFFFFFFFFF; + y = 64'h8010000000000001; + z = 64'h4340000000000000; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6035957\n"); + end + x = 64'h4010001FFFFFFFDF; + y = 64'h801FFFFFFFFFFFFE; + z = 64'hBFB0000001400000; + ans = 64'hBFB0000001400000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6037971\n"); + end + x = 64'hBFB9B0D01A1EF3DF; + y = 64'h800D29B35E6B84D3; + z = 64'hFFEFFFF77FFFFFFF; + ans = 64'hFFEFFFF77FFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6039985\n"); + end + x = 64'hFFFFFFFFFFFFFFFF; + y = 64'hBFD0000000000000; + z = 64'hFFFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6041999\n"); + end + x = 64'h402FFFFF80000001; + y = 64'hBFDFFFFFFFFFFFFE; + z = 64'hC03FFFFFFFFF0000; + ans = 64'hC043FFFFEFFF8000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6044013\n"); + end + x = 64'h163C00007FFFFFFF; + y = 64'hBE00000500000000; + z = 64'h3FD0008000FFFFFF; + ans = 64'h3FD0008000FFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6046027\n"); + end + x = 64'hFFFFFFFFFFFFFFFF; + y = 64'hBFF0000000000000; + 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,"6048041\n"); + end + x = 64'hBCA000000FFFFF7F; + y = 64'hBFFFFFFFFFFFFFFE; + z = 64'h4F7DFFFFFF800000; + ans = 64'h4F7DFFFFFF800000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6050055\n"); + end + x = 64'h8F9B54FF9BC5939D; + y = 64'hBB9FFFEFBFFFFFFF; + z = 64'h002FFFFFFFFE003F; + ans = 64'h0B4B54F1BA9BC682; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6052069\n"); + end + x = 64'hFFFFFFFFFFFFFFFF; + y = 64'hC010000000000000; + 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,"6054083\n"); + end + x = 64'hFFD1E1144D4A4CD4; + y = 64'hC01FFFFFFFFFFFFF; + z = 64'h80200000000800FF; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6056097\n"); + end + x = 64'hC1F69B9D2D0F9BBF; + y = 64'h400B5D4B36FADBE1; + z = 64'hC1C0007FFFFFFFFB; + ans = 64'hC213D53A026056B2; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6058111\n"); + end + x = 64'hFFFFFFFFFFFFFFFF; + y = 64'hC34FFFFFFFFFFFFE; + 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,"6060125\n"); + end + x = 64'hC15FFFFFBFFFFEFF; + y = 64'hFFEFFFFFFFFFFFFF; + z = 64'hB7EFFF7FFFFEFFFE; + ans = 64'h7FF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6062139\n"); + end + x = 64'h7FD0000210000000; + y = 64'h3FB0000000FFFF80; + z = 64'h381FFFFFFFFF9FFE; + ans = 64'h7F90000210FFFFA1; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6064153\n"); + end + x = 64'hFFFFFFFFFFFFFFFF; + y = 64'hFFFFFFFFFFFFFFFE; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'hFFFFFFFFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6066167\n"); + end + x = 64'hDF359A6296089E41; + y = 64'h000FFFFFFFFFFFFF; + z = 64'h3FC0000000002040; + ans = 64'h3FC0000000002040; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6068181\n"); + end + x = 64'h80000000005FFFFE; + y = 64'hBFCFE07FFFFFFFFE; + z = 64'h43E006FFFFFFFFFF; + ans = 64'h43E006FFFFFFFFFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6070195\n"); + end + x = 64'hFFFFFFFFFFFFFFFE; + y = 64'h001FFFFFFFFFFFFE; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6072209\n"); + end + x = 64'hBCAFE0000000FFFF; + y = 64'h3CA0000000000001; + z = 64'hB4CFFFF7FFFBFFFF; + ans = 64'hB95FE00000010001; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6074223\n"); + end + x = 64'hBFB003FFFFFFBFFF; + y = 64'h4D1E03FFFFFFFFFE; + z = 64'hC6600FFFBFFFFFFF; + ans = 64'hCCDE0B80FFFF87EC; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6076237\n"); + end + x = 64'hFFFFFFFFFFFFFFFE; + y = 64'h3FDFFFFFFFFFFFFF; + z = 64'hBFF0000000000001; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6078251\n"); + end + x = 64'hBF5007FFFFFFFC00; + y = 64'h3FE0000000000001; + z = 64'hBFB38FF7C65863E1; + ans = 64'hBFB3B007C65863D9; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6080265\n"); + end + x = 64'hB93FFFFFFFFFFE01; + y = 64'h3E1FFFFBEFFFFFFF; + z = 64'h400FBFFFFFFFC000; + ans = 64'h400FBFFFFFFFC000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6082279\n"); + end + x = 64'hFFFFFFFFFFFFFFFE; + y = 64'h3FFFFFFFFFFFFFFF; + z = 64'h4340000000000000; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6084293\n"); + end + x = 64'h4F50000FFFFFF7FF; + y = 64'h4000000000000000; + z = 64'h400FFFFFF8020000; + ans = 64'h4F60000FFFFFF7FF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6086307\n"); + end + x = 64'hC00000007FFFFFFF; + y = 64'h380000000083FFFE; + z = 64'h41EFFF7FFFF7FFFE; + ans = 64'h41EFFF7FFFF7FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6088321\n"); + end + x = 64'hFFFFFFFFFFFFFFFE; + y = 64'h4010000000000001; + 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,"6090335\n"); + end + x = 64'h43D000000008FFFF; + y = 64'h4340000000000000; + z = 64'h43D4197DC6387237; + ans = 64'h4720000000090000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6092349\n"); + end + x = 64'h57C0000000083FFE; + y = 64'hBFB00FFFDFFFFFFF; + z = 64'hC004862AC35E2530; + ans = 64'hD7800FFFE008483D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6094363\n"); + end + x = 64'hFFFFFFFFFFFFFFFE; + y = 64'h7FE0000000000001; + z = 64'hBCAFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6096377\n"); + end + x = 64'hBFE0000080FFFFFF; + y = 64'h7FF0000000000000; + z = 64'h56EFEFFFFFFFFF00; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6098391\n"); + end + x = 64'hBF650C6E8C6C58E9; + y = 64'h403000000000007B; + z = 64'hBCB010003FFFFFFF; + ans = 64'hBFA50C6E8C6C59AB; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6100405\n"); + end + x = 64'hFFFFFFFFFFFFFFFE; y = 64'h8000000000000001; - zrf = 64'h0000000000000000; - ans = 64'h8000000200000000; + z = 64'h3FF0000000000001; + ans = 64'hFFFFFFFFFFFFFFFE; rn = 1; rz = 0; rm = 0; @@ -462350,19 +142419,19 @@ initial // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this // standard does not interpret the sign of a NaN." wnan = &w[62:52] && |w[51:0]; - xnan = &xrf[62:52] && |xrf[51:0]; + xnan = &x[62:52] && |x[51:0]; ynan = &y[62:52] && |y[51:0]; - znan = &zrf[62:52] && |zrf[51:0]; + znan = &z[62:52] && |z[51:0]; ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|xrf[62:52]) && |xrf[51:0] ? {xrf[50:0], 1'b0} : xrf; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {xrf[62:52],1'b1,xrf[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {zrf[62:52],1'b1,zrf[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",xrf,y, zrf, w, ans); + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|xrf[62:52]) && |xrf[51:0]) $fwrite(fp, "xdenorm "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|zrf[62:52]) && |zrf[51:0]) $fwrite(fp, "zdenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); if(invalid != 0) $fwrite(fp, "invld "); if(overflow != 0) $fwrite(fp, "ovrflw "); if(underflow != 0) $fwrite(fp, "unflw "); @@ -462378,7 +142447,618 @@ initial if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6039335\n"); + $fwrite(fp,"6102419\n"); + end + x = 64'hC1E0400007FFFFFF; + y = 64'h800FFFFFFFFFFFFE; + z = 64'hBFC242ECB9B591F6; + ans = 64'hBFC242ECB9B591F6; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6104433\n"); + end + x = 64'h3FDACC860B03EBFD; + y = 64'h37F1000000000020; + z = 64'h3ED4E23C48598653; + ans = 64'h3ED4E23C48598653; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6106447\n"); + end + x = 64'hFFFFFFFFFFFFFFFE; + y = 64'hBCA0000000000000; + z = 64'hC340000000000000; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6108461\n"); + end + x = 64'hC030000FBFFFFFFE; + y = 64'hBCAFFFFFFFFFFFFE; + z = 64'h3FE07FFFFFFFBFFF; + ans = 64'h3FE07FFFFFFFC01F; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6110475\n"); + end + x = 64'hE4A61C37264327A3; + y = 64'hB80003FFFFFFFFFF; + z = 64'h5DBFDFFFFFFFFFFB; + ans = 64'h5DBFE01621BE3408; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6112489\n"); + end + x = 64'hFFFFFFFFFFFFFFFE; + y = 64'hBFE0000000000000; + z = 64'h7FFFFFFFFFFFFFFE; + ans = 64'h7FFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6114503\n"); + end + x = 64'h4180000800000FFF; + y = 64'hBFEFFFFFFFFFFFFE; + z = 64'hBFF0000020003FFF; + ans = 64'hC18000080800100E; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6116517\n"); + end + x = 64'hC3E32B3DE3BF21A9; + y = 64'h7FE002000003FFFF; + z = 64'h482FBFFFFFFBFFFF; + ans = 64'hFFF0000000000000; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6118531\n"); + end + x = 64'hFFFFFFFFFFFFFFFE; + y = 64'hC000000000000000; + z = 64'h3CAFFFFFFFFFFFFF; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6120545\n"); + end + x = 64'hC06F7FFFFF7FFFFF; + y = 64'hC00FFFFFFFFFFFFF; + z = 64'hBFF100000FFFFFFE; + ans = 64'h408F777FFF77FFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6122559\n"); + end + x = 64'hB81001FEFFFFFFFF; + y = 64'h800B7B70556EE1BD; + z = 64'hB9F0400000001FFF; + ans = 64'hB9F0400000001FFF; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6124573\n"); + end + x = 64'hFFFFFFFFFFFFFFFE; + y = 64'hC01FFFFFFFFFFFFE; + z = 64'hBFF0000000000001; + ans = 64'hFFFFFFFFFFFFFFFE; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6126587\n"); + end + x = 64'hC34000000002000E; + y = 64'hC34FFFFFFFFFFFFF; + z = 64'h37E0020000200000; + ans = 64'h46A000000002000D; + rn = 1; + rz = 0; + rm = 0; + rp = 0; + earlyres = 64'b0; + earlyressel = 0; + bypsel= 2'b0; + bypplus1 = 0; + byppostnorm = 0; +#10 + // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this + // standard does not interpret the sign of a NaN." + wnan = &w[62:52] && |w[51:0]; + xnan = &x[62:52] && |x[51:0]; + ynan = &y[62:52] && |y[51:0]; + znan = &z[62:52] && |z[51:0]; + ansnan = &ans[62:52] && |ans[51:0]; + xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; + ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; + s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; + if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin + $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); + if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); + if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); + if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); + if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); + if(invalid != 0) $fwrite(fp, "invld "); + if(overflow != 0) $fwrite(fp, "ovrflw "); + if(underflow != 0) $fwrite(fp, "unflw "); + if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); + if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); + if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); + if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); + if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); + if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); + if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); + if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); + $fwrite(fp,"6128601\n"); end $stop; end diff --git a/wally-pipelined/src/fpu/FMA/tbgen/tbhead.v b/wally-pipelined/src/fpu/FMA/tbgen/tbhead.v index 2a0c6791..c5613cc4 100644 --- a/wally-pipelined/src/fpu/FMA/tbgen/tbhead.v +++ b/wally-pipelined/src/fpu/FMA/tbgen/tbhead.v @@ -2,9 +2,9 @@ module tb; - reg [63:0] xrf; + reg [63:0] x; reg [63:0] y; - reg [63:0] zrf; + reg [63:0] z; reg [63:0] ans; reg rn; reg rz; @@ -33,9 +33,7 @@ reg [51:0] xnorm; reg [51:0] ynorm; localparam period = 20; -fmac UUT(.xrf(xrf), .y(y), .zrf(zrf), .rn(rn), .rz(rz), .rp(rp), .rm(rm), - .earlyres(earlyres), .earlyressel(earlyressel), .bypsel(bypsel), .bypplus1(bypplus1), .byppostnorm(byppostnorm), - .w(w), .wbypass(wbypass), .invalid(invalid), .overflow(overflow), .underflow(underflow), .inexact(inexact)); +fmac UUT(.*); initial